1: <?php
2: // @formatter:off
3: // phpcs:ignoreFile
4:
5: /**
6: * A helper file for Laravel, to provide autocomplete information to your IDE
7: * Generated for Laravel 9.21.3.
8: *
9: * This file should not be included in your code, only analyzed by your IDE!
10: *
11: * @author Barry vd. Heuvel <barryvdh@gmail.com>
12: * @see https://github.com/barryvdh/laravel-ide-helper
13: */
14:
15: namespace Illuminate\Support\Facades {
16: /**
17: *
18: *
19: * @see \Illuminate\Contracts\Foundation\Application
20: */
21: class App {
22: /**
23: * Get the version number of the application.
24: *
25: * @return string
26: * @static
27: */
28: public static function version()
29: {
30: /** @var \Illuminate\Foundation\Application $instance */
31: return $instance->version();
32: }
33: /**
34: * Run the given array of bootstrap classes.
35: *
36: * @param string[] $bootstrappers
37: * @return void
38: * @static
39: */
40: public static function bootstrapWith($bootstrappers)
41: {
42: /** @var \Illuminate\Foundation\Application $instance */
43: $instance->bootstrapWith($bootstrappers);
44: }
45: /**
46: * Register a callback to run after loading the environment.
47: *
48: * @param \Closure $callback
49: * @return void
50: * @static
51: */
52: public static function afterLoadingEnvironment($callback)
53: {
54: /** @var \Illuminate\Foundation\Application $instance */
55: $instance->afterLoadingEnvironment($callback);
56: }
57: /**
58: * Register a callback to run before a bootstrapper.
59: *
60: * @param string $bootstrapper
61: * @param \Closure $callback
62: * @return void
63: * @static
64: */
65: public static function beforeBootstrapping($bootstrapper, $callback)
66: {
67: /** @var \Illuminate\Foundation\Application $instance */
68: $instance->beforeBootstrapping($bootstrapper, $callback);
69: }
70: /**
71: * Register a callback to run after a bootstrapper.
72: *
73: * @param string $bootstrapper
74: * @param \Closure $callback
75: * @return void
76: * @static
77: */
78: public static function afterBootstrapping($bootstrapper, $callback)
79: {
80: /** @var \Illuminate\Foundation\Application $instance */
81: $instance->afterBootstrapping($bootstrapper, $callback);
82: }
83: /**
84: * Determine if the application has been bootstrapped before.
85: *
86: * @return bool
87: * @static
88: */
89: public static function hasBeenBootstrapped()
90: {
91: /** @var \Illuminate\Foundation\Application $instance */
92: return $instance->hasBeenBootstrapped();
93: }
94: /**
95: * Set the base path for the application.
96: *
97: * @param string $basePath
98: * @return \Illuminate\Foundation\Application
99: * @static
100: */
101: public static function setBasePath($basePath)
102: {
103: /** @var \Illuminate\Foundation\Application $instance */
104: return $instance->setBasePath($basePath);
105: }
106: /**
107: * Get the path to the application "app" directory.
108: *
109: * @param string $path
110: * @return string
111: * @static
112: */
113: public static function path($path = '')
114: {
115: /** @var \Illuminate\Foundation\Application $instance */
116: return $instance->path($path);
117: }
118: /**
119: * Set the application directory.
120: *
121: * @param string $path
122: * @return \Illuminate\Foundation\Application
123: * @static
124: */
125: public static function useAppPath($path)
126: {
127: /** @var \Illuminate\Foundation\Application $instance */
128: return $instance->useAppPath($path);
129: }
130: /**
131: * Get the base path of the Laravel installation.
132: *
133: * @param string $path
134: * @return string
135: * @static
136: */
137: public static function basePath($path = '')
138: {
139: /** @var \Illuminate\Foundation\Application $instance */
140: return $instance->basePath($path);
141: }
142: /**
143: * Get the path to the bootstrap directory.
144: *
145: * @param string $path
146: * @return string
147: * @static
148: */
149: public static function bootstrapPath($path = '')
150: {
151: /** @var \Illuminate\Foundation\Application $instance */
152: return $instance->bootstrapPath($path);
153: }
154: /**
155: * Get the path to the application configuration files.
156: *
157: * @param string $path
158: * @return string
159: * @static
160: */
161: public static function configPath($path = '')
162: {
163: /** @var \Illuminate\Foundation\Application $instance */
164: return $instance->configPath($path);
165: }
166: /**
167: * Get the path to the database directory.
168: *
169: * @param string $path
170: * @return string
171: * @static
172: */
173: public static function databasePath($path = '')
174: {
175: /** @var \Illuminate\Foundation\Application $instance */
176: return $instance->databasePath($path);
177: }
178: /**
179: * Set the database directory.
180: *
181: * @param string $path
182: * @return \Illuminate\Foundation\Application
183: * @static
184: */
185: public static function useDatabasePath($path)
186: {
187: /** @var \Illuminate\Foundation\Application $instance */
188: return $instance->useDatabasePath($path);
189: }
190: /**
191: * Get the path to the language files.
192: *
193: * @param string $path
194: * @return string
195: * @static
196: */
197: public static function langPath($path = '')
198: {
199: /** @var \Illuminate\Foundation\Application $instance */
200: return $instance->langPath($path);
201: }
202: /**
203: * Set the language file directory.
204: *
205: * @param string $path
206: * @return \Illuminate\Foundation\Application
207: * @static
208: */
209: public static function useLangPath($path)
210: {
211: /** @var \Illuminate\Foundation\Application $instance */
212: return $instance->useLangPath($path);
213: }
214: /**
215: * Get the path to the public / web directory.
216: *
217: * @return string
218: * @static
219: */
220: public static function publicPath()
221: {
222: /** @var \Illuminate\Foundation\Application $instance */
223: return $instance->publicPath();
224: }
225: /**
226: * Get the path to the storage directory.
227: *
228: * @param string $path
229: * @return string
230: * @static
231: */
232: public static function storagePath($path = '')
233: {
234: /** @var \Illuminate\Foundation\Application $instance */
235: return $instance->storagePath($path);
236: }
237: /**
238: * Set the storage directory.
239: *
240: * @param string $path
241: * @return \Illuminate\Foundation\Application
242: * @static
243: */
244: public static function useStoragePath($path)
245: {
246: /** @var \Illuminate\Foundation\Application $instance */
247: return $instance->useStoragePath($path);
248: }
249: /**
250: * Get the path to the resources directory.
251: *
252: * @param string $path
253: * @return string
254: * @static
255: */
256: public static function resourcePath($path = '')
257: {
258: /** @var \Illuminate\Foundation\Application $instance */
259: return $instance->resourcePath($path);
260: }
261: /**
262: * Get the path to the views directory.
263: *
264: * This method returns the first configured path in the array of view paths.
265: *
266: * @param string $path
267: * @return string
268: * @static
269: */
270: public static function viewPath($path = '')
271: {
272: /** @var \Illuminate\Foundation\Application $instance */
273: return $instance->viewPath($path);
274: }
275: /**
276: * Get the path to the environment file directory.
277: *
278: * @return string
279: * @static
280: */
281: public static function environmentPath()
282: {
283: /** @var \Illuminate\Foundation\Application $instance */
284: return $instance->environmentPath();
285: }
286: /**
287: * Set the directory for the environment file.
288: *
289: * @param string $path
290: * @return \Illuminate\Foundation\Application
291: * @static
292: */
293: public static function useEnvironmentPath($path)
294: {
295: /** @var \Illuminate\Foundation\Application $instance */
296: return $instance->useEnvironmentPath($path);
297: }
298: /**
299: * Set the environment file to be loaded during bootstrapping.
300: *
301: * @param string $file
302: * @return \Illuminate\Foundation\Application
303: * @static
304: */
305: public static function loadEnvironmentFrom($file)
306: {
307: /** @var \Illuminate\Foundation\Application $instance */
308: return $instance->loadEnvironmentFrom($file);
309: }
310: /**
311: * Get the environment file the application is using.
312: *
313: * @return string
314: * @static
315: */
316: public static function environmentFile()
317: {
318: /** @var \Illuminate\Foundation\Application $instance */
319: return $instance->environmentFile();
320: }
321: /**
322: * Get the fully qualified path to the environment file.
323: *
324: * @return string
325: * @static
326: */
327: public static function environmentFilePath()
328: {
329: /** @var \Illuminate\Foundation\Application $instance */
330: return $instance->environmentFilePath();
331: }
332: /**
333: * Get or check the current application environment.
334: *
335: * @param string|array $environments
336: * @return string|bool
337: * @static
338: */
339: public static function environment(...$environments)
340: {
341: /** @var \Illuminate\Foundation\Application $instance */
342: return $instance->environment(...$environments);
343: }
344: /**
345: * Determine if the application is in the local environment.
346: *
347: * @return bool
348: * @static
349: */
350: public static function isLocal()
351: {
352: /** @var \Illuminate\Foundation\Application $instance */
353: return $instance->isLocal();
354: }
355: /**
356: * Determine if the application is in the production environment.
357: *
358: * @return bool
359: * @static
360: */
361: public static function isProduction()
362: {
363: /** @var \Illuminate\Foundation\Application $instance */
364: return $instance->isProduction();
365: }
366: /**
367: * Detect the application's current environment.
368: *
369: * @param \Closure $callback
370: * @return string
371: * @static
372: */
373: public static function detectEnvironment($callback)
374: {
375: /** @var \Illuminate\Foundation\Application $instance */
376: return $instance->detectEnvironment($callback);
377: }
378: /**
379: * Determine if the application is running in the console.
380: *
381: * @return bool
382: * @static
383: */
384: public static function runningInConsole()
385: {
386: /** @var \Illuminate\Foundation\Application $instance */
387: return $instance->runningInConsole();
388: }
389: /**
390: * Determine if the application is running unit tests.
391: *
392: * @return bool
393: * @static
394: */
395: public static function runningUnitTests()
396: {
397: /** @var \Illuminate\Foundation\Application $instance */
398: return $instance->runningUnitTests();
399: }
400: /**
401: * Determine if the application is running with debug mode enabled.
402: *
403: * @return bool
404: * @static
405: */
406: public static function hasDebugModeEnabled()
407: {
408: /** @var \Illuminate\Foundation\Application $instance */
409: return $instance->hasDebugModeEnabled();
410: }
411: /**
412: * Register all of the configured providers.
413: *
414: * @return void
415: * @static
416: */
417: public static function registerConfiguredProviders()
418: {
419: /** @var \Illuminate\Foundation\Application $instance */
420: $instance->registerConfiguredProviders();
421: }
422: /**
423: * Register a service provider with the application.
424: *
425: * @param \Illuminate\Support\ServiceProvider|string $provider
426: * @param bool $force
427: * @return \Illuminate\Support\ServiceProvider
428: * @static
429: */
430: public static function register($provider, $force = false)
431: {
432: /** @var \Illuminate\Foundation\Application $instance */
433: return $instance->register($provider, $force);
434: }
435: /**
436: * Get the registered service provider instance if it exists.
437: *
438: * @param \Illuminate\Support\ServiceProvider|string $provider
439: * @return \Illuminate\Support\ServiceProvider|null
440: * @static
441: */
442: public static function getProvider($provider)
443: {
444: /** @var \Illuminate\Foundation\Application $instance */
445: return $instance->getProvider($provider);
446: }
447: /**
448: * Get the registered service provider instances if any exist.
449: *
450: * @param \Illuminate\Support\ServiceProvider|string $provider
451: * @return array
452: * @static
453: */
454: public static function getProviders($provider)
455: {
456: /** @var \Illuminate\Foundation\Application $instance */
457: return $instance->getProviders($provider);
458: }
459: /**
460: * Resolve a service provider instance from the class name.
461: *
462: * @param string $provider
463: * @return \Illuminate\Support\ServiceProvider
464: * @static
465: */
466: public static function resolveProvider($provider)
467: {
468: /** @var \Illuminate\Foundation\Application $instance */
469: return $instance->resolveProvider($provider);
470: }
471: /**
472: * Load and boot all of the remaining deferred providers.
473: *
474: * @return void
475: * @static
476: */
477: public static function loadDeferredProviders()
478: {
479: /** @var \Illuminate\Foundation\Application $instance */
480: $instance->loadDeferredProviders();
481: }
482: /**
483: * Load the provider for a deferred service.
484: *
485: * @param string $service
486: * @return void
487: * @static
488: */
489: public static function loadDeferredProvider($service)
490: {
491: /** @var \Illuminate\Foundation\Application $instance */
492: $instance->loadDeferredProvider($service);
493: }
494: /**
495: * Register a deferred provider and service.
496: *
497: * @param string $provider
498: * @param string|null $service
499: * @return void
500: * @static
501: */
502: public static function registerDeferredProvider($provider, $service = null)
503: {
504: /** @var \Illuminate\Foundation\Application $instance */
505: $instance->registerDeferredProvider($provider, $service);
506: }
507: /**
508: * Resolve the given type from the container.
509: *
510: * @param string $abstract
511: * @param array $parameters
512: * @return mixed
513: * @static
514: */
515: public static function make($abstract, $parameters = [])
516: {
517: /** @var \Illuminate\Foundation\Application $instance */
518: return $instance->make($abstract, $parameters);
519: }
520: /**
521: * Determine if the given abstract type has been bound.
522: *
523: * @param string $abstract
524: * @return bool
525: * @static
526: */
527: public static function bound($abstract)
528: {
529: /** @var \Illuminate\Foundation\Application $instance */
530: return $instance->bound($abstract);
531: }
532: /**
533: * Determine if the application has booted.
534: *
535: * @return bool
536: * @static
537: */
538: public static function isBooted()
539: {
540: /** @var \Illuminate\Foundation\Application $instance */
541: return $instance->isBooted();
542: }
543: /**
544: * Boot the application's service providers.
545: *
546: * @return void
547: * @static
548: */
549: public static function boot()
550: {
551: /** @var \Illuminate\Foundation\Application $instance */
552: $instance->boot();
553: }
554: /**
555: * Register a new boot listener.
556: *
557: * @param callable $callback
558: * @return void
559: * @static
560: */
561: public static function booting($callback)
562: {
563: /** @var \Illuminate\Foundation\Application $instance */
564: $instance->booting($callback);
565: }
566: /**
567: * Register a new "booted" listener.
568: *
569: * @param callable $callback
570: * @return void
571: * @static
572: */
573: public static function booted($callback)
574: {
575: /** @var \Illuminate\Foundation\Application $instance */
576: $instance->booted($callback);
577: }
578: /**
579: * {@inheritdoc}
580: *
581: * @return \Symfony\Component\HttpFoundation\Response
582: * @static
583: */
584: public static function handle($request, $type = 1, $catch = true)
585: {
586: /** @var \Illuminate\Foundation\Application $instance */
587: return $instance->handle($request, $type, $catch);
588: }
589: /**
590: * Determine if middleware has been disabled for the application.
591: *
592: * @return bool
593: * @static
594: */
595: public static function shouldSkipMiddleware()
596: {
597: /** @var \Illuminate\Foundation\Application $instance */
598: return $instance->shouldSkipMiddleware();
599: }
600: /**
601: * Get the path to the cached services.php file.
602: *
603: * @return string
604: * @static
605: */
606: public static function getCachedServicesPath()
607: {
608: /** @var \Illuminate\Foundation\Application $instance */
609: return $instance->getCachedServicesPath();
610: }
611: /**
612: * Get the path to the cached packages.php file.
613: *
614: * @return string
615: * @static
616: */
617: public static function getCachedPackagesPath()
618: {
619: /** @var \Illuminate\Foundation\Application $instance */
620: return $instance->getCachedPackagesPath();
621: }
622: /**
623: * Determine if the application configuration is cached.
624: *
625: * @return bool
626: * @static
627: */
628: public static function configurationIsCached()
629: {
630: /** @var \Illuminate\Foundation\Application $instance */
631: return $instance->configurationIsCached();
632: }
633: /**
634: * Get the path to the configuration cache file.
635: *
636: * @return string
637: * @static
638: */
639: public static function getCachedConfigPath()
640: {
641: /** @var \Illuminate\Foundation\Application $instance */
642: return $instance->getCachedConfigPath();
643: }
644: /**
645: * Determine if the application routes are cached.
646: *
647: * @return bool
648: * @static
649: */
650: public static function routesAreCached()
651: {
652: /** @var \Illuminate\Foundation\Application $instance */
653: return $instance->routesAreCached();
654: }
655: /**
656: * Get the path to the routes cache file.
657: *
658: * @return string
659: * @static
660: */
661: public static function getCachedRoutesPath()
662: {
663: /** @var \Illuminate\Foundation\Application $instance */
664: return $instance->getCachedRoutesPath();
665: }
666: /**
667: * Determine if the application events are cached.
668: *
669: * @return bool
670: * @static
671: */
672: public static function eventsAreCached()
673: {
674: /** @var \Illuminate\Foundation\Application $instance */
675: return $instance->eventsAreCached();
676: }
677: /**
678: * Get the path to the events cache file.
679: *
680: * @return string
681: * @static
682: */
683: public static function getCachedEventsPath()
684: {
685: /** @var \Illuminate\Foundation\Application $instance */
686: return $instance->getCachedEventsPath();
687: }
688: /**
689: * Add new prefix to list of absolute path prefixes.
690: *
691: * @param string $prefix
692: * @return \Illuminate\Foundation\Application
693: * @static
694: */
695: public static function addAbsoluteCachePathPrefix($prefix)
696: {
697: /** @var \Illuminate\Foundation\Application $instance */
698: return $instance->addAbsoluteCachePathPrefix($prefix);
699: }
700: /**
701: * Get an instance of the maintenance mode manager implementation.
702: *
703: * @return \Illuminate\Contracts\Foundation\MaintenanceMode
704: * @static
705: */
706: public static function maintenanceMode()
707: {
708: /** @var \Illuminate\Foundation\Application $instance */
709: return $instance->maintenanceMode();
710: }
711: /**
712: * Determine if the application is currently down for maintenance.
713: *
714: * @return bool
715: * @static
716: */
717: public static function isDownForMaintenance()
718: {
719: /** @var \Illuminate\Foundation\Application $instance */
720: return $instance->isDownForMaintenance();
721: }
722: /**
723: * Throw an HttpException with the given data.
724: *
725: * @param int $code
726: * @param string $message
727: * @param array $headers
728: * @return \Illuminate\Foundation\never
729: * @throws \Symfony\Component\HttpKernel\Exception\HttpException
730: * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
731: * @static
732: */
733: public static function abort($code, $message = '', $headers = [])
734: {
735: /** @var \Illuminate\Foundation\Application $instance */
736: return $instance->abort($code, $message, $headers);
737: }
738: /**
739: * Register a terminating callback with the application.
740: *
741: * @param callable|string $callback
742: * @return \Illuminate\Foundation\Application
743: * @static
744: */
745: public static function terminating($callback)
746: {
747: /** @var \Illuminate\Foundation\Application $instance */
748: return $instance->terminating($callback);
749: }
750: /**
751: * Terminate the application.
752: *
753: * @return void
754: * @static
755: */
756: public static function terminate()
757: {
758: /** @var \Illuminate\Foundation\Application $instance */
759: $instance->terminate();
760: }
761: /**
762: * Get the service providers that have been loaded.
763: *
764: * @return array
765: * @static
766: */
767: public static function getLoadedProviders()
768: {
769: /** @var \Illuminate\Foundation\Application $instance */
770: return $instance->getLoadedProviders();
771: }
772: /**
773: * Determine if the given service provider is loaded.
774: *
775: * @param string $provider
776: * @return bool
777: * @static
778: */
779: public static function providerIsLoaded($provider)
780: {
781: /** @var \Illuminate\Foundation\Application $instance */
782: return $instance->providerIsLoaded($provider);
783: }
784: /**
785: * Get the application's deferred services.
786: *
787: * @return array
788: * @static
789: */
790: public static function getDeferredServices()
791: {
792: /** @var \Illuminate\Foundation\Application $instance */
793: return $instance->getDeferredServices();
794: }
795: /**
796: * Set the application's deferred services.
797: *
798: * @param array $services
799: * @return void
800: * @static
801: */
802: public static function setDeferredServices($services)
803: {
804: /** @var \Illuminate\Foundation\Application $instance */
805: $instance->setDeferredServices($services);
806: }
807: /**
808: * Add an array of services to the application's deferred services.
809: *
810: * @param array $services
811: * @return void
812: * @static
813: */
814: public static function addDeferredServices($services)
815: {
816: /** @var \Illuminate\Foundation\Application $instance */
817: $instance->addDeferredServices($services);
818: }
819: /**
820: * Determine if the given service is a deferred service.
821: *
822: * @param string $service
823: * @return bool
824: * @static
825: */
826: public static function isDeferredService($service)
827: {
828: /** @var \Illuminate\Foundation\Application $instance */
829: return $instance->isDeferredService($service);
830: }
831: /**
832: * Configure the real-time facade namespace.
833: *
834: * @param string $namespace
835: * @return void
836: * @static
837: */
838: public static function provideFacades($namespace)
839: {
840: /** @var \Illuminate\Foundation\Application $instance */
841: $instance->provideFacades($namespace);
842: }
843: /**
844: * Get the current application locale.
845: *
846: * @return string
847: * @static
848: */
849: public static function getLocale()
850: {
851: /** @var \Illuminate\Foundation\Application $instance */
852: return $instance->getLocale();
853: }
854: /**
855: * Get the current application locale.
856: *
857: * @return string
858: * @static
859: */
860: public static function currentLocale()
861: {
862: /** @var \Illuminate\Foundation\Application $instance */
863: return $instance->currentLocale();
864: }
865: /**
866: * Get the current application fallback locale.
867: *
868: * @return string
869: * @static
870: */
871: public static function getFallbackLocale()
872: {
873: /** @var \Illuminate\Foundation\Application $instance */
874: return $instance->getFallbackLocale();
875: }
876: /**
877: * Set the current application locale.
878: *
879: * @param string $locale
880: * @return void
881: * @static
882: */
883: public static function setLocale($locale)
884: {
885: /** @var \Illuminate\Foundation\Application $instance */
886: $instance->setLocale($locale);
887: }
888: /**
889: * Set the current application fallback locale.
890: *
891: * @param string $fallbackLocale
892: * @return void
893: * @static
894: */
895: public static function setFallbackLocale($fallbackLocale)
896: {
897: /** @var \Illuminate\Foundation\Application $instance */
898: $instance->setFallbackLocale($fallbackLocale);
899: }
900: /**
901: * Determine if the application locale is the given locale.
902: *
903: * @param string $locale
904: * @return bool
905: * @static
906: */
907: public static function isLocale($locale)
908: {
909: /** @var \Illuminate\Foundation\Application $instance */
910: return $instance->isLocale($locale);
911: }
912: /**
913: * Register the core class aliases in the container.
914: *
915: * @return void
916: * @static
917: */
918: public static function registerCoreContainerAliases()
919: {
920: /** @var \Illuminate\Foundation\Application $instance */
921: $instance->registerCoreContainerAliases();
922: }
923: /**
924: * Flush the container of all bindings and resolved instances.
925: *
926: * @return void
927: * @static
928: */
929: public static function flush()
930: {
931: /** @var \Illuminate\Foundation\Application $instance */
932: $instance->flush();
933: }
934: /**
935: * Get the application namespace.
936: *
937: * @return string
938: * @throws \RuntimeException
939: * @static
940: */
941: public static function getNamespace()
942: {
943: /** @var \Illuminate\Foundation\Application $instance */
944: return $instance->getNamespace();
945: }
946: /**
947: * Define a contextual binding.
948: *
949: * @param array|string $concrete
950: * @return \Illuminate\Contracts\Container\ContextualBindingBuilder
951: * @static
952: */
953: public static function when($concrete)
954: { //Method inherited from \Illuminate\Container\Container
955: /** @var \Illuminate\Foundation\Application $instance */
956: return $instance->when($concrete);
957: }
958: /**
959: * Returns true if the container can return an entry for the given identifier.
960: *
961: * Returns false otherwise.
962: *
963: * `has($id)` returning true does not mean that `get($id)` will not throw an exception.
964: * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`.
965: *
966: * @return bool
967: * @param string $id Identifier of the entry to look for.
968: * @return bool
969: * @static
970: */
971: public static function has($id)
972: { //Method inherited from \Illuminate\Container\Container
973: /** @var \Illuminate\Foundation\Application $instance */
974: return $instance->has($id);
975: }
976: /**
977: * Determine if the given abstract type has been resolved.
978: *
979: * @param string $abstract
980: * @return bool
981: * @static
982: */
983: public static function resolved($abstract)
984: { //Method inherited from \Illuminate\Container\Container
985: /** @var \Illuminate\Foundation\Application $instance */
986: return $instance->resolved($abstract);
987: }
988: /**
989: * Determine if a given type is shared.
990: *
991: * @param string $abstract
992: * @return bool
993: * @static
994: */
995: public static function isShared($abstract)
996: { //Method inherited from \Illuminate\Container\Container
997: /** @var \Illuminate\Foundation\Application $instance */
998: return $instance->isShared($abstract);
999: }
1000: /**
1001: * Determine if a given string is an alias.
1002: *
1003: * @param string $name
1004: * @return bool
1005: * @static
1006: */
1007: public static function isAlias($name)
1008: { //Method inherited from \Illuminate\Container\Container
1009: /** @var \Illuminate\Foundation\Application $instance */
1010: return $instance->isAlias($name);
1011: }
1012: /**
1013: * Register a binding with the container.
1014: *
1015: * @param string $abstract
1016: * @param \Closure|string|null $concrete
1017: * @param bool $shared
1018: * @return void
1019: * @throws \TypeError
1020: * @static
1021: */
1022: public static function bind($abstract, $concrete = null, $shared = false)
1023: { //Method inherited from \Illuminate\Container\Container
1024: /** @var \Illuminate\Foundation\Application $instance */
1025: $instance->bind($abstract, $concrete, $shared);
1026: }
1027: /**
1028: * Determine if the container has a method binding.
1029: *
1030: * @param string $method
1031: * @return bool
1032: * @static
1033: */
1034: public static function hasMethodBinding($method)
1035: { //Method inherited from \Illuminate\Container\Container
1036: /** @var \Illuminate\Foundation\Application $instance */
1037: return $instance->hasMethodBinding($method);
1038: }
1039: /**
1040: * Bind a callback to resolve with Container::call.
1041: *
1042: * @param array|string $method
1043: * @param \Closure $callback
1044: * @return void
1045: * @static
1046: */
1047: public static function bindMethod($method, $callback)
1048: { //Method inherited from \Illuminate\Container\Container
1049: /** @var \Illuminate\Foundation\Application $instance */
1050: $instance->bindMethod($method, $callback);
1051: }
1052: /**
1053: * Get the method binding for the given method.
1054: *
1055: * @param string $method
1056: * @param mixed $instance
1057: * @return mixed
1058: * @static
1059: */
1060: public static function callMethodBinding($method, $instance)
1061: { //Method inherited from \Illuminate\Container\Container
1062: /** @var \Illuminate\Foundation\Application $instance */
1063: return $instance->callMethodBinding($method, $instance);
1064: }
1065: /**
1066: * Add a contextual binding to the container.
1067: *
1068: * @param string $concrete
1069: * @param string $abstract
1070: * @param \Closure|string $implementation
1071: * @return void
1072: * @static
1073: */
1074: public static function addContextualBinding($concrete, $abstract, $implementation)
1075: { //Method inherited from \Illuminate\Container\Container
1076: /** @var \Illuminate\Foundation\Application $instance */
1077: $instance->addContextualBinding($concrete, $abstract, $implementation);
1078: }
1079: /**
1080: * Register a binding if it hasn't already been registered.
1081: *
1082: * @param string $abstract
1083: * @param \Closure|string|null $concrete
1084: * @param bool $shared
1085: * @return void
1086: * @static
1087: */
1088: public static function bindIf($abstract, $concrete = null, $shared = false)
1089: { //Method inherited from \Illuminate\Container\Container
1090: /** @var \Illuminate\Foundation\Application $instance */
1091: $instance->bindIf($abstract, $concrete, $shared);
1092: }
1093: /**
1094: * Register a shared binding in the container.
1095: *
1096: * @param string $abstract
1097: * @param \Closure|string|null $concrete
1098: * @return void
1099: * @static
1100: */
1101: public static function singleton($abstract, $concrete = null)
1102: { //Method inherited from \Illuminate\Container\Container
1103: /** @var \Illuminate\Foundation\Application $instance */
1104: $instance->singleton($abstract, $concrete);
1105: }
1106: /**
1107: * Register a shared binding if it hasn't already been registered.
1108: *
1109: * @param string $abstract
1110: * @param \Closure|string|null $concrete
1111: * @return void
1112: * @static
1113: */
1114: public static function singletonIf($abstract, $concrete = null)
1115: { //Method inherited from \Illuminate\Container\Container
1116: /** @var \Illuminate\Foundation\Application $instance */
1117: $instance->singletonIf($abstract, $concrete);
1118: }
1119: /**
1120: * Register a scoped binding in the container.
1121: *
1122: * @param string $abstract
1123: * @param \Closure|string|null $concrete
1124: * @return void
1125: * @static
1126: */
1127: public static function scoped($abstract, $concrete = null)
1128: { //Method inherited from \Illuminate\Container\Container
1129: /** @var \Illuminate\Foundation\Application $instance */
1130: $instance->scoped($abstract, $concrete);
1131: }
1132: /**
1133: * Register a scoped binding if it hasn't already been registered.
1134: *
1135: * @param string $abstract
1136: * @param \Closure|string|null $concrete
1137: * @return void
1138: * @static
1139: */
1140: public static function scopedIf($abstract, $concrete = null)
1141: { //Method inherited from \Illuminate\Container\Container
1142: /** @var \Illuminate\Foundation\Application $instance */
1143: $instance->scopedIf($abstract, $concrete);
1144: }
1145: /**
1146: * "Extend" an abstract type in the container.
1147: *
1148: * @param string $abstract
1149: * @param \Closure $closure
1150: * @return void
1151: * @throws \InvalidArgumentException
1152: * @static
1153: */
1154: public static function extend($abstract, $closure)
1155: { //Method inherited from \Illuminate\Container\Container
1156: /** @var \Illuminate\Foundation\Application $instance */
1157: $instance->extend($abstract, $closure);
1158: }
1159: /**
1160: * Register an existing instance as shared in the container.
1161: *
1162: * @param string $abstract
1163: * @param mixed $instance
1164: * @return mixed
1165: * @static
1166: */
1167: public static function instance($abstract, $instance)
1168: { //Method inherited from \Illuminate\Container\Container
1169: /** @var \Illuminate\Foundation\Application $instance */
1170: return $instance->instance($abstract, $instance);
1171: }
1172: /**
1173: * Assign a set of tags to a given binding.
1174: *
1175: * @param array|string $abstracts
1176: * @param array|mixed $tags
1177: * @return void
1178: * @static
1179: */
1180: public static function tag($abstracts, $tags)
1181: { //Method inherited from \Illuminate\Container\Container
1182: /** @var \Illuminate\Foundation\Application $instance */
1183: $instance->tag($abstracts, $tags);
1184: }
1185: /**
1186: * Resolve all of the bindings for a given tag.
1187: *
1188: * @param string $tag
1189: * @return \Illuminate\Container\iterable
1190: * @static
1191: */
1192: public static function tagged($tag)
1193: { //Method inherited from \Illuminate\Container\Container
1194: /** @var \Illuminate\Foundation\Application $instance */
1195: return $instance->tagged($tag);
1196: }
1197: /**
1198: * Alias a type to a different name.
1199: *
1200: * @param string $abstract
1201: * @param string $alias
1202: * @return void
1203: * @throws \LogicException
1204: * @static
1205: */
1206: public static function alias($abstract, $alias)
1207: { //Method inherited from \Illuminate\Container\Container
1208: /** @var \Illuminate\Foundation\Application $instance */
1209: $instance->alias($abstract, $alias);
1210: }
1211: /**
1212: * Bind a new callback to an abstract's rebind event.
1213: *
1214: * @param string $abstract
1215: * @param \Closure $callback
1216: * @return mixed
1217: * @static
1218: */
1219: public static function rebinding($abstract, $callback)
1220: { //Method inherited from \Illuminate\Container\Container
1221: /** @var \Illuminate\Foundation\Application $instance */
1222: return $instance->rebinding($abstract, $callback);
1223: }
1224: /**
1225: * Refresh an instance on the given target and method.
1226: *
1227: * @param string $abstract
1228: * @param mixed $target
1229: * @param string $method
1230: * @return mixed
1231: * @static
1232: */
1233: public static function refresh($abstract, $target, $method)
1234: { //Method inherited from \Illuminate\Container\Container
1235: /** @var \Illuminate\Foundation\Application $instance */
1236: return $instance->refresh($abstract, $target, $method);
1237: }
1238: /**
1239: * Wrap the given closure such that its dependencies will be injected when executed.
1240: *
1241: * @param \Closure $callback
1242: * @param array $parameters
1243: * @return \Closure
1244: * @static
1245: */
1246: public static function wrap($callback, $parameters = [])
1247: { //Method inherited from \Illuminate\Container\Container
1248: /** @var \Illuminate\Foundation\Application $instance */
1249: return $instance->wrap($callback, $parameters);
1250: }
1251: /**
1252: * Call the given Closure / class@method and inject its dependencies.
1253: *
1254: * @param callable|string $callback
1255: * @param \Illuminate\Container\array<string, mixed> $parameters
1256: * @param string|null $defaultMethod
1257: * @return mixed
1258: * @throws \InvalidArgumentException
1259: * @static
1260: */
1261: public static function call($callback, $parameters = [], $defaultMethod = null)
1262: { //Method inherited from \Illuminate\Container\Container
1263: /** @var \Illuminate\Foundation\Application $instance */
1264: return $instance->call($callback, $parameters, $defaultMethod);
1265: }
1266: /**
1267: * Get a closure to resolve the given type from the container.
1268: *
1269: * @param string $abstract
1270: * @return \Closure
1271: * @static
1272: */
1273: public static function factory($abstract)
1274: { //Method inherited from \Illuminate\Container\Container
1275: /** @var \Illuminate\Foundation\Application $instance */
1276: return $instance->factory($abstract);
1277: }
1278: /**
1279: * An alias function name for make().
1280: *
1281: * @param string|callable $abstract
1282: * @param array $parameters
1283: * @return mixed
1284: * @throws \Illuminate\Contracts\Container\BindingResolutionException
1285: * @static
1286: */
1287: public static function makeWith($abstract, $parameters = [])
1288: { //Method inherited from \Illuminate\Container\Container
1289: /** @var \Illuminate\Foundation\Application $instance */
1290: return $instance->makeWith($abstract, $parameters);
1291: }
1292: /**
1293: * Finds an entry of the container by its identifier and returns it.
1294: *
1295: * @return mixed
1296: * @param string $id Identifier of the entry to look for.
1297: * @throws NotFoundExceptionInterface No entry was found for **this** identifier.
1298: * @throws ContainerExceptionInterface Error while retrieving the entry.
1299: * @return mixed Entry.
1300: * @static
1301: */
1302: public static function get($id)
1303: { //Method inherited from \Illuminate\Container\Container
1304: /** @var \Illuminate\Foundation\Application $instance */
1305: return $instance->get($id);
1306: }
1307: /**
1308: * Instantiate a concrete instance of the given type.
1309: *
1310: * @param \Closure|string $concrete
1311: * @return mixed
1312: * @throws \Illuminate\Contracts\Container\BindingResolutionException
1313: * @throws \Illuminate\Contracts\Container\CircularDependencyException
1314: * @static
1315: */
1316: public static function build($concrete)
1317: { //Method inherited from \Illuminate\Container\Container
1318: /** @var \Illuminate\Foundation\Application $instance */
1319: return $instance->build($concrete);
1320: }
1321: /**
1322: * Register a new before resolving callback for all types.
1323: *
1324: * @param \Closure|string $abstract
1325: * @param \Closure|null $callback
1326: * @return void
1327: * @static
1328: */
1329: public static function beforeResolving($abstract, $callback = null)
1330: { //Method inherited from \Illuminate\Container\Container
1331: /** @var \Illuminate\Foundation\Application $instance */
1332: $instance->beforeResolving($abstract, $callback);
1333: }
1334: /**
1335: * Register a new resolving callback.
1336: *
1337: * @param \Closure|string $abstract
1338: * @param \Closure|null $callback
1339: * @return void
1340: * @static
1341: */
1342: public static function resolving($abstract, $callback = null)
1343: { //Method inherited from \Illuminate\Container\Container
1344: /** @var \Illuminate\Foundation\Application $instance */
1345: $instance->resolving($abstract, $callback);
1346: }
1347: /**
1348: * Register a new after resolving callback for all types.
1349: *
1350: * @param \Closure|string $abstract
1351: * @param \Closure|null $callback
1352: * @return void
1353: * @static
1354: */
1355: public static function afterResolving($abstract, $callback = null)
1356: { //Method inherited from \Illuminate\Container\Container
1357: /** @var \Illuminate\Foundation\Application $instance */
1358: $instance->afterResolving($abstract, $callback);
1359: }
1360: /**
1361: * Get the container's bindings.
1362: *
1363: * @return array
1364: * @static
1365: */
1366: public static function getBindings()
1367: { //Method inherited from \Illuminate\Container\Container
1368: /** @var \Illuminate\Foundation\Application $instance */
1369: return $instance->getBindings();
1370: }
1371: /**
1372: * Get the alias for an abstract if available.
1373: *
1374: * @param string $abstract
1375: * @return string
1376: * @static
1377: */
1378: public static function getAlias($abstract)
1379: { //Method inherited from \Illuminate\Container\Container
1380: /** @var \Illuminate\Foundation\Application $instance */
1381: return $instance->getAlias($abstract);
1382: }
1383: /**
1384: * Remove all of the extender callbacks for a given type.
1385: *
1386: * @param string $abstract
1387: * @return void
1388: * @static
1389: */
1390: public static function forgetExtenders($abstract)
1391: { //Method inherited from \Illuminate\Container\Container
1392: /** @var \Illuminate\Foundation\Application $instance */
1393: $instance->forgetExtenders($abstract);
1394: }
1395: /**
1396: * Remove a resolved instance from the instance cache.
1397: *
1398: * @param string $abstract
1399: * @return void
1400: * @static
1401: */
1402: public static function forgetInstance($abstract)
1403: { //Method inherited from \Illuminate\Container\Container
1404: /** @var \Illuminate\Foundation\Application $instance */
1405: $instance->forgetInstance($abstract);
1406: }
1407: /**
1408: * Clear all of the instances from the container.
1409: *
1410: * @return void
1411: * @static
1412: */
1413: public static function forgetInstances()
1414: { //Method inherited from \Illuminate\Container\Container
1415: /** @var \Illuminate\Foundation\Application $instance */
1416: $instance->forgetInstances();
1417: }
1418: /**
1419: * Clear all of the scoped instances from the container.
1420: *
1421: * @return void
1422: * @static
1423: */
1424: public static function forgetScopedInstances()
1425: { //Method inherited from \Illuminate\Container\Container
1426: /** @var \Illuminate\Foundation\Application $instance */
1427: $instance->forgetScopedInstances();
1428: }
1429: /**
1430: * Get the globally available instance of the container.
1431: *
1432: * @return static
1433: * @static
1434: */
1435: public static function getInstance()
1436: { //Method inherited from \Illuminate\Container\Container
1437: return \Illuminate\Foundation\Application::getInstance();
1438: }
1439: /**
1440: * Set the shared instance of the container.
1441: *
1442: * @param \Illuminate\Contracts\Container\Container|null $container
1443: * @return \Illuminate\Contracts\Container\Container|static
1444: * @static
1445: */
1446: public static function setInstance($container = null)
1447: { //Method inherited from \Illuminate\Container\Container
1448: return \Illuminate\Foundation\Application::setInstance($container);
1449: }
1450: /**
1451: * Determine if a given offset exists.
1452: *
1453: * @param string $key
1454: * @return bool
1455: * @static
1456: */
1457: public static function offsetExists($key)
1458: { //Method inherited from \Illuminate\Container\Container
1459: /** @var \Illuminate\Foundation\Application $instance */
1460: return $instance->offsetExists($key);
1461: }
1462: /**
1463: * Get the value at a given offset.
1464: *
1465: * @param string $key
1466: * @return mixed
1467: * @static
1468: */
1469: public static function offsetGet($key)
1470: { //Method inherited from \Illuminate\Container\Container
1471: /** @var \Illuminate\Foundation\Application $instance */
1472: return $instance->offsetGet($key);
1473: }
1474: /**
1475: * Set the value at a given offset.
1476: *
1477: * @param string $key
1478: * @param mixed $value
1479: * @return void
1480: * @static
1481: */
1482: public static function offsetSet($key, $value)
1483: { //Method inherited from \Illuminate\Container\Container
1484: /** @var \Illuminate\Foundation\Application $instance */
1485: $instance->offsetSet($key, $value);
1486: }
1487: /**
1488: * Unset the value at a given offset.
1489: *
1490: * @param string $key
1491: * @return void
1492: * @static
1493: */
1494: public static function offsetUnset($key)
1495: { //Method inherited from \Illuminate\Container\Container
1496: /** @var \Illuminate\Foundation\Application $instance */
1497: $instance->offsetUnset($key);
1498: }
1499:
1500: }
1501: /**
1502: *
1503: *
1504: * @see \Illuminate\Contracts\Console\Kernel
1505: */
1506: class Artisan {
1507: /**
1508: * Run the console application.
1509: *
1510: * @param \Symfony\Component\Console\Input\InputInterface $input
1511: * @param \Symfony\Component\Console\Output\OutputInterface|null $output
1512: * @return int
1513: * @static
1514: */
1515: public static function handle($input, $output = null)
1516: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1517: /** @var \App\Console\Kernel $instance */
1518: return $instance->handle($input, $output);
1519: }
1520: /**
1521: * Terminate the application.
1522: *
1523: * @param \Symfony\Component\Console\Input\InputInterface $input
1524: * @param int $status
1525: * @return void
1526: * @static
1527: */
1528: public static function terminate($input, $status)
1529: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1530: /** @var \App\Console\Kernel $instance */
1531: $instance->terminate($input, $status);
1532: }
1533: /**
1534: * Register a Closure based command with the application.
1535: *
1536: * @param string $signature
1537: * @param \Closure $callback
1538: * @return \Illuminate\Foundation\Console\ClosureCommand
1539: * @static
1540: */
1541: public static function command($signature, $callback)
1542: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1543: /** @var \App\Console\Kernel $instance */
1544: return $instance->command($signature, $callback);
1545: }
1546: /**
1547: * Register the given command with the console application.
1548: *
1549: * @param \Symfony\Component\Console\Command\Command $command
1550: * @return void
1551: * @static
1552: */
1553: public static function registerCommand($command)
1554: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1555: /** @var \App\Console\Kernel $instance */
1556: $instance->registerCommand($command);
1557: }
1558: /**
1559: * Run an Artisan console command by name.
1560: *
1561: * @param string $command
1562: * @param array $parameters
1563: * @param \Symfony\Component\Console\Output\OutputInterface|null $outputBuffer
1564: * @return int
1565: * @throws \Symfony\Component\Console\Exception\CommandNotFoundException
1566: * @static
1567: */
1568: public static function call($command, $parameters = [], $outputBuffer = null)
1569: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1570: /** @var \App\Console\Kernel $instance */
1571: return $instance->call($command, $parameters, $outputBuffer);
1572: }
1573: /**
1574: * Queue the given console command.
1575: *
1576: * @param string $command
1577: * @param array $parameters
1578: * @return \Illuminate\Foundation\Bus\PendingDispatch
1579: * @static
1580: */
1581: public static function queue($command, $parameters = [])
1582: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1583: /** @var \App\Console\Kernel $instance */
1584: return $instance->queue($command, $parameters);
1585: }
1586: /**
1587: * Get all of the commands registered with the console.
1588: *
1589: * @return array
1590: * @static
1591: */
1592: public static function all()
1593: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1594: /** @var \App\Console\Kernel $instance */
1595: return $instance->all();
1596: }
1597: /**
1598: * Get the output for the last run command.
1599: *
1600: * @return string
1601: * @static
1602: */
1603: public static function output()
1604: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1605: /** @var \App\Console\Kernel $instance */
1606: return $instance->output();
1607: }
1608: /**
1609: * Bootstrap the application for artisan commands.
1610: *
1611: * @return void
1612: * @static
1613: */
1614: public static function bootstrap()
1615: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1616: /** @var \App\Console\Kernel $instance */
1617: $instance->bootstrap();
1618: }
1619: /**
1620: * Set the Artisan application instance.
1621: *
1622: * @param \Illuminate\Console\Application $artisan
1623: * @return void
1624: * @static
1625: */
1626: public static function setArtisan($artisan)
1627: { //Method inherited from \Illuminate\Foundation\Console\Kernel
1628: /** @var \App\Console\Kernel $instance */
1629: $instance->setArtisan($artisan);
1630: }
1631:
1632: }
1633: /**
1634: *
1635: *
1636: * @see \Illuminate\Auth\AuthManager
1637: * @see \Illuminate\Contracts\Auth\Factory
1638: * @see \Illuminate\Contracts\Auth\Guard
1639: * @see \Illuminate\Contracts\Auth\StatefulGuard
1640: */
1641: class Auth {
1642: /**
1643: * Attempt to get the guard from the local cache.
1644: *
1645: * @param string|null $name
1646: * @return \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard
1647: * @static
1648: */
1649: public static function guard($name = null)
1650: {
1651: /** @var \Illuminate\Auth\AuthManager $instance */
1652: return $instance->guard($name);
1653: }
1654: /**
1655: * Create a session based authentication guard.
1656: *
1657: * @param string $name
1658: * @param array $config
1659: * @return \Illuminate\Auth\SessionGuard
1660: * @static
1661: */
1662: public static function createSessionDriver($name, $config)
1663: {
1664: /** @var \Illuminate\Auth\AuthManager $instance */
1665: return $instance->createSessionDriver($name, $config);
1666: }
1667: /**
1668: * Create a token based authentication guard.
1669: *
1670: * @param string $name
1671: * @param array $config
1672: * @return \Illuminate\Auth\TokenGuard
1673: * @static
1674: */
1675: public static function createTokenDriver($name, $config)
1676: {
1677: /** @var \Illuminate\Auth\AuthManager $instance */
1678: return $instance->createTokenDriver($name, $config);
1679: }
1680: /**
1681: * Get the default authentication driver name.
1682: *
1683: * @return string
1684: * @static
1685: */
1686: public static function getDefaultDriver()
1687: {
1688: /** @var \Illuminate\Auth\AuthManager $instance */
1689: return $instance->getDefaultDriver();
1690: }
1691: /**
1692: * Set the default guard driver the factory should serve.
1693: *
1694: * @param string $name
1695: * @return void
1696: * @static
1697: */
1698: public static function shouldUse($name)
1699: {
1700: /** @var \Illuminate\Auth\AuthManager $instance */
1701: $instance->shouldUse($name);
1702: }
1703: /**
1704: * Set the default authentication driver name.
1705: *
1706: * @param string $name
1707: * @return void
1708: * @static
1709: */
1710: public static function setDefaultDriver($name)
1711: {
1712: /** @var \Illuminate\Auth\AuthManager $instance */
1713: $instance->setDefaultDriver($name);
1714: }
1715: /**
1716: * Register a new callback based request guard.
1717: *
1718: * @param string $driver
1719: * @param callable $callback
1720: * @return \Illuminate\Auth\AuthManager
1721: * @static
1722: */
1723: public static function viaRequest($driver, $callback)
1724: {
1725: /** @var \Illuminate\Auth\AuthManager $instance */
1726: return $instance->viaRequest($driver, $callback);
1727: }
1728: /**
1729: * Get the user resolver callback.
1730: *
1731: * @return \Closure
1732: * @static
1733: */
1734: public static function userResolver()
1735: {
1736: /** @var \Illuminate\Auth\AuthManager $instance */
1737: return $instance->userResolver();
1738: }
1739: /**
1740: * Set the callback to be used to resolve users.
1741: *
1742: * @param \Closure $userResolver
1743: * @return \Illuminate\Auth\AuthManager
1744: * @static
1745: */
1746: public static function resolveUsersUsing($userResolver)
1747: {
1748: /** @var \Illuminate\Auth\AuthManager $instance */
1749: return $instance->resolveUsersUsing($userResolver);
1750: }
1751: /**
1752: * Register a custom driver creator Closure.
1753: *
1754: * @param string $driver
1755: * @param \Closure $callback
1756: * @return \Illuminate\Auth\AuthManager
1757: * @static
1758: */
1759: public static function extend($driver, $callback)
1760: {
1761: /** @var \Illuminate\Auth\AuthManager $instance */
1762: return $instance->extend($driver, $callback);
1763: }
1764: /**
1765: * Register a custom provider creator Closure.
1766: *
1767: * @param string $name
1768: * @param \Closure $callback
1769: * @return \Illuminate\Auth\AuthManager
1770: * @static
1771: */
1772: public static function provider($name, $callback)
1773: {
1774: /** @var \Illuminate\Auth\AuthManager $instance */
1775: return $instance->provider($name, $callback);
1776: }
1777: /**
1778: * Determines if any guards have already been resolved.
1779: *
1780: * @return bool
1781: * @static
1782: */
1783: public static function hasResolvedGuards()
1784: {
1785: /** @var \Illuminate\Auth\AuthManager $instance */
1786: return $instance->hasResolvedGuards();
1787: }
1788: /**
1789: * Forget all of the resolved guard instances.
1790: *
1791: * @return \Illuminate\Auth\AuthManager
1792: * @static
1793: */
1794: public static function forgetGuards()
1795: {
1796: /** @var \Illuminate\Auth\AuthManager $instance */
1797: return $instance->forgetGuards();
1798: }
1799: /**
1800: * Set the application instance used by the manager.
1801: *
1802: * @param \Illuminate\Contracts\Foundation\Application $app
1803: * @return \Illuminate\Auth\AuthManager
1804: * @static
1805: */
1806: public static function setApplication($app)
1807: {
1808: /** @var \Illuminate\Auth\AuthManager $instance */
1809: return $instance->setApplication($app);
1810: }
1811: /**
1812: * Create the user provider implementation for the driver.
1813: *
1814: * @param string|null $provider
1815: * @return \Illuminate\Contracts\Auth\UserProvider|null
1816: * @throws \InvalidArgumentException
1817: * @static
1818: */
1819: public static function createUserProvider($provider = null)
1820: {
1821: /** @var \Illuminate\Auth\AuthManager $instance */
1822: return $instance->createUserProvider($provider);
1823: }
1824: /**
1825: * Get the default user provider name.
1826: *
1827: * @return string
1828: * @static
1829: */
1830: public static function getDefaultUserProvider()
1831: {
1832: /** @var \Illuminate\Auth\AuthManager $instance */
1833: return $instance->getDefaultUserProvider();
1834: }
1835: /**
1836: * Get the currently authenticated user.
1837: *
1838: * @return \App\Models\User|null
1839: * @static
1840: */
1841: public static function user()
1842: {
1843: /** @var \Illuminate\Auth\SessionGuard $instance */
1844: return $instance->user();
1845: }
1846: /**
1847: * Get the ID for the currently authenticated user.
1848: *
1849: * @return int|string|null
1850: * @static
1851: */
1852: public static function id()
1853: {
1854: /** @var \Illuminate\Auth\SessionGuard $instance */
1855: return $instance->id();
1856: }
1857: /**
1858: * Log a user into the application without sessions or cookies.
1859: *
1860: * @param array $credentials
1861: * @return bool
1862: * @static
1863: */
1864: public static function once($credentials = [])
1865: {
1866: /** @var \Illuminate\Auth\SessionGuard $instance */
1867: return $instance->once($credentials);
1868: }
1869: /**
1870: * Log the given user ID into the application without sessions or cookies.
1871: *
1872: * @param mixed $id
1873: * @return \App\Models\User|false
1874: * @static
1875: */
1876: public static function onceUsingId($id)
1877: {
1878: /** @var \Illuminate\Auth\SessionGuard $instance */
1879: return $instance->onceUsingId($id);
1880: }
1881: /**
1882: * Validate a user's credentials.
1883: *
1884: * @param array $credentials
1885: * @return bool
1886: * @static
1887: */
1888: public static function validate($credentials = [])
1889: {
1890: /** @var \Illuminate\Auth\SessionGuard $instance */
1891: return $instance->validate($credentials);
1892: }
1893: /**
1894: * Attempt to authenticate using HTTP Basic Auth.
1895: *
1896: * @param string $field
1897: * @param array $extraConditions
1898: * @return \Symfony\Component\HttpFoundation\Response|null
1899: * @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException
1900: * @static
1901: */
1902: public static function basic($field = 'email', $extraConditions = [])
1903: {
1904: /** @var \Illuminate\Auth\SessionGuard $instance */
1905: return $instance->basic($field, $extraConditions);
1906: }
1907: /**
1908: * Perform a stateless HTTP Basic login attempt.
1909: *
1910: * @param string $field
1911: * @param array $extraConditions
1912: * @return \Symfony\Component\HttpFoundation\Response|null
1913: * @throws \Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException
1914: * @static
1915: */
1916: public static function onceBasic($field = 'email', $extraConditions = [])
1917: {
1918: /** @var \Illuminate\Auth\SessionGuard $instance */
1919: return $instance->onceBasic($field, $extraConditions);
1920: }
1921: /**
1922: * Attempt to authenticate a user using the given credentials.
1923: *
1924: * @param array $credentials
1925: * @param bool $remember
1926: * @return bool
1927: * @static
1928: */
1929: public static function attempt($credentials = [], $remember = false)
1930: {
1931: /** @var \Illuminate\Auth\SessionGuard $instance */
1932: return $instance->attempt($credentials, $remember);
1933: }
1934: /**
1935: * Attempt to authenticate a user with credentials and additional callbacks.
1936: *
1937: * @param array $credentials
1938: * @param array|callable $callbacks
1939: * @param bool $remember
1940: * @return bool
1941: * @static
1942: */
1943: public static function attemptWhen($credentials = [], $callbacks = null, $remember = false)
1944: {
1945: /** @var \Illuminate\Auth\SessionGuard $instance */
1946: return $instance->attemptWhen($credentials, $callbacks, $remember);
1947: }
1948: /**
1949: * Log the given user ID into the application.
1950: *
1951: * @param mixed $id
1952: * @param bool $remember
1953: * @return \App\Models\User|false
1954: * @static
1955: */
1956: public static function loginUsingId($id, $remember = false)
1957: {
1958: /** @var \Illuminate\Auth\SessionGuard $instance */
1959: return $instance->loginUsingId($id, $remember);
1960: }
1961: /**
1962: * Log a user into the application.
1963: *
1964: * @param \Illuminate\Contracts\Auth\Authenticatable $user
1965: * @param bool $remember
1966: * @return void
1967: * @static
1968: */
1969: public static function login($user, $remember = false)
1970: {
1971: /** @var \Illuminate\Auth\SessionGuard $instance */
1972: $instance->login($user, $remember);
1973: }
1974: /**
1975: * Log the user out of the application.
1976: *
1977: * @return void
1978: * @static
1979: */
1980: public static function logout()
1981: {
1982: /** @var \Illuminate\Auth\SessionGuard $instance */
1983: $instance->logout();
1984: }
1985: /**
1986: * Log the user out of the application on their current device only.
1987: *
1988: * This method does not cycle the "remember" token.
1989: *
1990: * @return void
1991: * @static
1992: */
1993: public static function logoutCurrentDevice()
1994: {
1995: /** @var \Illuminate\Auth\SessionGuard $instance */
1996: $instance->logoutCurrentDevice();
1997: }
1998: /**
1999: * Invalidate other sessions for the current user.
2000: *
2001: * The application must be using the AuthenticateSession middleware.
2002: *
2003: * @param string $password
2004: * @param string $attribute
2005: * @return \App\Models\User|null
2006: * @throws \Illuminate\Auth\AuthenticationException
2007: * @static
2008: */
2009: public static function logoutOtherDevices($password, $attribute = 'password')
2010: {
2011: /** @var \Illuminate\Auth\SessionGuard $instance */
2012: return $instance->logoutOtherDevices($password, $attribute);
2013: }
2014: /**
2015: * Register an authentication attempt event listener.
2016: *
2017: * @param mixed $callback
2018: * @return void
2019: * @static
2020: */
2021: public static function attempting($callback)
2022: {
2023: /** @var \Illuminate\Auth\SessionGuard $instance */
2024: $instance->attempting($callback);
2025: }
2026: /**
2027: * Get the last user we attempted to authenticate.
2028: *
2029: * @return \App\Models\User
2030: * @static
2031: */
2032: public static function getLastAttempted()
2033: {
2034: /** @var \Illuminate\Auth\SessionGuard $instance */
2035: return $instance->getLastAttempted();
2036: }
2037: /**
2038: * Get a unique identifier for the auth session value.
2039: *
2040: * @return string
2041: * @static
2042: */
2043: public static function getName()
2044: {
2045: /** @var \Illuminate\Auth\SessionGuard $instance */
2046: return $instance->getName();
2047: }
2048: /**
2049: * Get the name of the cookie used to store the "recaller".
2050: *
2051: * @return string
2052: * @static
2053: */
2054: public static function getRecallerName()
2055: {
2056: /** @var \Illuminate\Auth\SessionGuard $instance */
2057: return $instance->getRecallerName();
2058: }
2059: /**
2060: * Determine if the user was authenticated via "remember me" cookie.
2061: *
2062: * @return bool
2063: * @static
2064: */
2065: public static function viaRemember()
2066: {
2067: /** @var \Illuminate\Auth\SessionGuard $instance */
2068: return $instance->viaRemember();
2069: }
2070: /**
2071: * Set the number of minutes the remember me cookie should be valid for.
2072: *
2073: * @param int $minutes
2074: * @return \Illuminate\Auth\SessionGuard
2075: * @static
2076: */
2077: public static function setRememberDuration($minutes)
2078: {
2079: /** @var \Illuminate\Auth\SessionGuard $instance */
2080: return $instance->setRememberDuration($minutes);
2081: }
2082: /**
2083: * Get the cookie creator instance used by the guard.
2084: *
2085: * @return \Illuminate\Contracts\Cookie\QueueingFactory
2086: * @throws \RuntimeException
2087: * @static
2088: */
2089: public static function getCookieJar()
2090: {
2091: /** @var \Illuminate\Auth\SessionGuard $instance */
2092: return $instance->getCookieJar();
2093: }
2094: /**
2095: * Set the cookie creator instance used by the guard.
2096: *
2097: * @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie
2098: * @return void
2099: * @static
2100: */
2101: public static function setCookieJar($cookie)
2102: {
2103: /** @var \Illuminate\Auth\SessionGuard $instance */
2104: $instance->setCookieJar($cookie);
2105: }
2106: /**
2107: * Get the event dispatcher instance.
2108: *
2109: * @return \Illuminate\Contracts\Events\Dispatcher
2110: * @static
2111: */
2112: public static function getDispatcher()
2113: {
2114: /** @var \Illuminate\Auth\SessionGuard $instance */
2115: return $instance->getDispatcher();
2116: }
2117: /**
2118: * Set the event dispatcher instance.
2119: *
2120: * @param \Illuminate\Contracts\Events\Dispatcher $events
2121: * @return void
2122: * @static
2123: */
2124: public static function setDispatcher($events)
2125: {
2126: /** @var \Illuminate\Auth\SessionGuard $instance */
2127: $instance->setDispatcher($events);
2128: }
2129: /**
2130: * Get the session store used by the guard.
2131: *
2132: * @return \Illuminate\Contracts\Session\Session
2133: * @static
2134: */
2135: public static function getSession()
2136: {
2137: /** @var \Illuminate\Auth\SessionGuard $instance */
2138: return $instance->getSession();
2139: }
2140: /**
2141: * Return the currently cached user.
2142: *
2143: * @return \App\Models\User|null
2144: * @static
2145: */
2146: public static function getUser()
2147: {
2148: /** @var \Illuminate\Auth\SessionGuard $instance */
2149: return $instance->getUser();
2150: }
2151: /**
2152: * Set the current user.
2153: *
2154: * @param \Illuminate\Contracts\Auth\Authenticatable $user
2155: * @return \Illuminate\Auth\SessionGuard
2156: * @static
2157: */
2158: public static function setUser($user)
2159: {
2160: /** @var \Illuminate\Auth\SessionGuard $instance */
2161: return $instance->setUser($user);
2162: }
2163: /**
2164: * Get the current request instance.
2165: *
2166: * @return \Symfony\Component\HttpFoundation\Request
2167: * @static
2168: */
2169: public static function getRequest()
2170: {
2171: /** @var \Illuminate\Auth\SessionGuard $instance */
2172: return $instance->getRequest();
2173: }
2174: /**
2175: * Set the current request instance.
2176: *
2177: * @param \Symfony\Component\HttpFoundation\Request $request
2178: * @return \Illuminate\Auth\SessionGuard
2179: * @static
2180: */
2181: public static function setRequest($request)
2182: {
2183: /** @var \Illuminate\Auth\SessionGuard $instance */
2184: return $instance->setRequest($request);
2185: }
2186: /**
2187: * Determine if the current user is authenticated. If not, throw an exception.
2188: *
2189: * @return \App\Models\User
2190: * @throws \Illuminate\Auth\AuthenticationException
2191: * @static
2192: */
2193: public static function authenticate()
2194: {
2195: /** @var \Illuminate\Auth\SessionGuard $instance */
2196: return $instance->authenticate();
2197: }
2198: /**
2199: * Determine if the guard has a user instance.
2200: *
2201: * @return bool
2202: * @static
2203: */
2204: public static function hasUser()
2205: {
2206: /** @var \Illuminate\Auth\SessionGuard $instance */
2207: return $instance->hasUser();
2208: }
2209: /**
2210: * Determine if the current user is authenticated.
2211: *
2212: * @return bool
2213: * @static
2214: */
2215: public static function check()
2216: {
2217: /** @var \Illuminate\Auth\SessionGuard $instance */
2218: return $instance->check();
2219: }
2220: /**
2221: * Determine if the current user is a guest.
2222: *
2223: * @return bool
2224: * @static
2225: */
2226: public static function guest()
2227: {
2228: /** @var \Illuminate\Auth\SessionGuard $instance */
2229: return $instance->guest();
2230: }
2231: /**
2232: * Get the user provider used by the guard.
2233: *
2234: * @return \Illuminate\Contracts\Auth\UserProvider
2235: * @static
2236: */
2237: public static function getProvider()
2238: {
2239: /** @var \Illuminate\Auth\SessionGuard $instance */
2240: return $instance->getProvider();
2241: }
2242: /**
2243: * Set the user provider used by the guard.
2244: *
2245: * @param \Illuminate\Contracts\Auth\UserProvider $provider
2246: * @return void
2247: * @static
2248: */
2249: public static function setProvider($provider)
2250: {
2251: /** @var \Illuminate\Auth\SessionGuard $instance */
2252: $instance->setProvider($provider);
2253: }
2254: /**
2255: * Register a custom macro.
2256: *
2257: * @param string $name
2258: * @param object|callable $macro
2259: * @return void
2260: * @static
2261: */
2262: public static function macro($name, $macro)
2263: {
2264: \Illuminate\Auth\SessionGuard::macro($name, $macro);
2265: }
2266: /**
2267: * Mix another object into the class.
2268: *
2269: * @param object $mixin
2270: * @param bool $replace
2271: * @return void
2272: * @throws \ReflectionException
2273: * @static
2274: */
2275: public static function mixin($mixin, $replace = true)
2276: {
2277: \Illuminate\Auth\SessionGuard::mixin($mixin, $replace);
2278: }
2279: /**
2280: * Checks if macro is registered.
2281: *
2282: * @param string $name
2283: * @return bool
2284: * @static
2285: */
2286: public static function hasMacro($name)
2287: {
2288: return \Illuminate\Auth\SessionGuard::hasMacro($name);
2289: }
2290: /**
2291: * Flush the existing macros.
2292: *
2293: * @return void
2294: * @static
2295: */
2296: public static function flushMacros()
2297: {
2298: \Illuminate\Auth\SessionGuard::flushMacros();
2299: }
2300:
2301: }
2302: /**
2303: *
2304: *
2305: * @see \Illuminate\View\Compilers\BladeCompiler
2306: */
2307: class Blade {
2308: /**
2309: * Compile the view at the given path.
2310: *
2311: * @param string|null $path
2312: * @return void
2313: * @static
2314: */
2315: public static function compile($path = null)
2316: {
2317: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2318: $instance->compile($path);
2319: }
2320: /**
2321: * Get the path currently being compiled.
2322: *
2323: * @return string
2324: * @static
2325: */
2326: public static function getPath()
2327: {
2328: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2329: return $instance->getPath();
2330: }
2331: /**
2332: * Set the path currently being compiled.
2333: *
2334: * @param string $path
2335: * @return void
2336: * @static
2337: */
2338: public static function setPath($path)
2339: {
2340: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2341: $instance->setPath($path);
2342: }
2343: /**
2344: * Compile the given Blade template contents.
2345: *
2346: * @param string $value
2347: * @return string
2348: * @static
2349: */
2350: public static function compileString($value)
2351: {
2352: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2353: return $instance->compileString($value);
2354: }
2355: /**
2356: * Evaluate and render a Blade string to HTML.
2357: *
2358: * @param string $string
2359: * @param array $data
2360: * @param bool $deleteCachedView
2361: * @return string
2362: * @static
2363: */
2364: public static function render($string, $data = [], $deleteCachedView = false)
2365: {
2366: return \Illuminate\View\Compilers\BladeCompiler::render($string, $data, $deleteCachedView);
2367: }
2368: /**
2369: * Render a component instance to HTML.
2370: *
2371: * @param \Illuminate\View\Component $component
2372: * @return string
2373: * @static
2374: */
2375: public static function renderComponent($component)
2376: {
2377: return \Illuminate\View\Compilers\BladeCompiler::renderComponent($component);
2378: }
2379: /**
2380: * Strip the parentheses from the given expression.
2381: *
2382: * @param string $expression
2383: * @return string
2384: * @static
2385: */
2386: public static function stripParentheses($expression)
2387: {
2388: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2389: return $instance->stripParentheses($expression);
2390: }
2391: /**
2392: * Register a custom Blade compiler.
2393: *
2394: * @param callable $compiler
2395: * @return void
2396: * @static
2397: */
2398: public static function extend($compiler)
2399: {
2400: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2401: $instance->extend($compiler);
2402: }
2403: /**
2404: * Get the extensions used by the compiler.
2405: *
2406: * @return array
2407: * @static
2408: */
2409: public static function getExtensions()
2410: {
2411: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2412: return $instance->getExtensions();
2413: }
2414: /**
2415: * Register an "if" statement directive.
2416: *
2417: * @param string $name
2418: * @param callable $callback
2419: * @return void
2420: * @static
2421: */
2422: public static function if($name, $callback)
2423: {
2424: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2425: $instance->if($name, $callback);
2426: }
2427: /**
2428: * Check the result of a condition.
2429: *
2430: * @param string $name
2431: * @param array $parameters
2432: * @return bool
2433: * @static
2434: */
2435: public static function check($name, ...$parameters)
2436: {
2437: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2438: return $instance->check($name, ...$parameters);
2439: }
2440: /**
2441: * Register a class-based component alias directive.
2442: *
2443: * @param string $class
2444: * @param string|null $alias
2445: * @param string $prefix
2446: * @return void
2447: * @static
2448: */
2449: public static function component($class, $alias = null, $prefix = '')
2450: {
2451: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2452: $instance->component($class, $alias, $prefix);
2453: }
2454: /**
2455: * Register an array of class-based components.
2456: *
2457: * @param array $components
2458: * @param string $prefix
2459: * @return void
2460: * @static
2461: */
2462: public static function components($components, $prefix = '')
2463: {
2464: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2465: $instance->components($components, $prefix);
2466: }
2467: /**
2468: * Get the registered class component aliases.
2469: *
2470: * @return array
2471: * @static
2472: */
2473: public static function getClassComponentAliases()
2474: {
2475: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2476: return $instance->getClassComponentAliases();
2477: }
2478: /**
2479: * Register an anonymous component namespace.
2480: *
2481: * @param string $directory
2482: * @param string|null $prefix
2483: * @return void
2484: * @static
2485: */
2486: public static function anonymousComponentNamespace($directory, $prefix = null)
2487: {
2488: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2489: $instance->anonymousComponentNamespace($directory, $prefix);
2490: }
2491: /**
2492: * Register a class-based component namespace.
2493: *
2494: * @param string $namespace
2495: * @param string $prefix
2496: * @return void
2497: * @static
2498: */
2499: public static function componentNamespace($namespace, $prefix)
2500: {
2501: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2502: $instance->componentNamespace($namespace, $prefix);
2503: }
2504: /**
2505: * Get the registered anonymous component namespaces.
2506: *
2507: * @return array
2508: * @static
2509: */
2510: public static function getAnonymousComponentNamespaces()
2511: {
2512: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2513: return $instance->getAnonymousComponentNamespaces();
2514: }
2515: /**
2516: * Get the registered class component namespaces.
2517: *
2518: * @return array
2519: * @static
2520: */
2521: public static function getClassComponentNamespaces()
2522: {
2523: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2524: return $instance->getClassComponentNamespaces();
2525: }
2526: /**
2527: * Register a component alias directive.
2528: *
2529: * @param string $path
2530: * @param string|null $alias
2531: * @return void
2532: * @static
2533: */
2534: public static function aliasComponent($path, $alias = null)
2535: {
2536: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2537: $instance->aliasComponent($path, $alias);
2538: }
2539: /**
2540: * Register an include alias directive.
2541: *
2542: * @param string $path
2543: * @param string|null $alias
2544: * @return void
2545: * @static
2546: */
2547: public static function include($path, $alias = null)
2548: {
2549: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2550: $instance->include($path, $alias);
2551: }
2552: /**
2553: * Register an include alias directive.
2554: *
2555: * @param string $path
2556: * @param string|null $alias
2557: * @return void
2558: * @static
2559: */
2560: public static function aliasInclude($path, $alias = null)
2561: {
2562: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2563: $instance->aliasInclude($path, $alias);
2564: }
2565: /**
2566: * Register a handler for custom directives.
2567: *
2568: * @param string $name
2569: * @param callable $handler
2570: * @return void
2571: * @throws \InvalidArgumentException
2572: * @static
2573: */
2574: public static function directive($name, $handler)
2575: {
2576: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2577: $instance->directive($name, $handler);
2578: }
2579: /**
2580: * Get the list of custom directives.
2581: *
2582: * @return array
2583: * @static
2584: */
2585: public static function getCustomDirectives()
2586: {
2587: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2588: return $instance->getCustomDirectives();
2589: }
2590: /**
2591: * Register a new precompiler.
2592: *
2593: * @param callable $precompiler
2594: * @return void
2595: * @static
2596: */
2597: public static function precompiler($precompiler)
2598: {
2599: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2600: $instance->precompiler($precompiler);
2601: }
2602: /**
2603: * Set the echo format to be used by the compiler.
2604: *
2605: * @param string $format
2606: * @return void
2607: * @static
2608: */
2609: public static function setEchoFormat($format)
2610: {
2611: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2612: $instance->setEchoFormat($format);
2613: }
2614: /**
2615: * Set the "echo" format to double encode entities.
2616: *
2617: * @return void
2618: * @static
2619: */
2620: public static function withDoubleEncoding()
2621: {
2622: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2623: $instance->withDoubleEncoding();
2624: }
2625: /**
2626: * Set the "echo" format to not double encode entities.
2627: *
2628: * @return void
2629: * @static
2630: */
2631: public static function withoutDoubleEncoding()
2632: {
2633: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2634: $instance->withoutDoubleEncoding();
2635: }
2636: /**
2637: * Indicate that component tags should not be compiled.
2638: *
2639: * @return void
2640: * @static
2641: */
2642: public static function withoutComponentTags()
2643: {
2644: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2645: $instance->withoutComponentTags();
2646: }
2647: /**
2648: * Get the path to the compiled version of a view.
2649: *
2650: * @param string $path
2651: * @return string
2652: * @static
2653: */
2654: public static function getCompiledPath($path)
2655: { //Method inherited from \Illuminate\View\Compilers\Compiler
2656: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2657: return $instance->getCompiledPath($path);
2658: }
2659: /**
2660: * Determine if the view at the given path is expired.
2661: *
2662: * @param string $path
2663: * @return bool
2664: * @static
2665: */
2666: public static function isExpired($path)
2667: { //Method inherited from \Illuminate\View\Compilers\Compiler
2668: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2669: return $instance->isExpired($path);
2670: }
2671: /**
2672: * Get a new component hash for a component name.
2673: *
2674: * @param string $component
2675: * @return string
2676: * @static
2677: */
2678: public static function newComponentHash($component)
2679: {
2680: return \Illuminate\View\Compilers\BladeCompiler::newComponentHash($component);
2681: }
2682: /**
2683: * Compile a class component opening.
2684: *
2685: * @param string $component
2686: * @param string $alias
2687: * @param string $data
2688: * @param string $hash
2689: * @return string
2690: * @static
2691: */
2692: public static function compileClassComponentOpening($component, $alias, $data, $hash)
2693: {
2694: return \Illuminate\View\Compilers\BladeCompiler::compileClassComponentOpening($component, $alias, $data, $hash);
2695: }
2696: /**
2697: * Compile the end-component statements into valid PHP.
2698: *
2699: * @return string
2700: * @static
2701: */
2702: public static function compileEndComponentClass()
2703: {
2704: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2705: return $instance->compileEndComponentClass();
2706: }
2707: /**
2708: * Sanitize the given component attribute value.
2709: *
2710: * @param mixed $value
2711: * @return mixed
2712: * @static
2713: */
2714: public static function sanitizeComponentAttribute($value)
2715: {
2716: return \Illuminate\View\Compilers\BladeCompiler::sanitizeComponentAttribute($value);
2717: }
2718: /**
2719: * Compile an end-once block into valid PHP.
2720: *
2721: * @return string
2722: * @static
2723: */
2724: public static function compileEndOnce()
2725: {
2726: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2727: return $instance->compileEndOnce();
2728: }
2729: /**
2730: * Add a handler to be executed before echoing a given class.
2731: *
2732: * @param string|callable $class
2733: * @param callable|null $handler
2734: * @return void
2735: * @static
2736: */
2737: public static function stringable($class, $handler = null)
2738: {
2739: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2740: $instance->stringable($class, $handler);
2741: }
2742: /**
2743: * Compile Blade echos into valid PHP.
2744: *
2745: * @param string $value
2746: * @return string
2747: * @static
2748: */
2749: public static function compileEchos($value)
2750: {
2751: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2752: return $instance->compileEchos($value);
2753: }
2754: /**
2755: * Apply the echo handler for the value if it exists.
2756: *
2757: * @param string $value
2758: * @return string
2759: * @static
2760: */
2761: public static function applyEchoHandler($value)
2762: {
2763: /** @var \Illuminate\View\Compilers\BladeCompiler $instance */
2764: return $instance->applyEchoHandler($value);
2765: }
2766:
2767: }
2768: /**
2769: *
2770: *
2771: * @method static \Illuminate\Broadcasting\Broadcasters\Broadcaster channel(string $channel, callable|string $callback, array $options = [])
2772: * @method static mixed auth(\Illuminate\Http\Request $request)
2773: * @method static void resolveAuthenticatedUserUsing(Closure $callback)
2774: * @see \Illuminate\Contracts\Broadcasting\Factory
2775: */
2776: class Broadcast {
2777: /**
2778: * Register the routes for handling broadcast channel authentication and sockets.
2779: *
2780: * @param array|null $attributes
2781: * @return void
2782: * @static
2783: */
2784: public static function routes($attributes = null)
2785: {
2786: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2787: $instance->routes($attributes);
2788: }
2789: /**
2790: * Register the routes for handling broadcast user authentication.
2791: *
2792: * @param array|null $attributes
2793: * @return void
2794: * @static
2795: */
2796: public static function userRoutes($attributes = null)
2797: {
2798: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2799: $instance->userRoutes($attributes);
2800: }
2801: /**
2802: * Register the routes for handling broadcast authentication and sockets.
2803: *
2804: * Alias of "routes" method.
2805: *
2806: * @param array|null $attributes
2807: * @return void
2808: * @static
2809: */
2810: public static function channelRoutes($attributes = null)
2811: {
2812: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2813: $instance->channelRoutes($attributes);
2814: }
2815: /**
2816: * Get the socket ID for the given request.
2817: *
2818: * @param \Illuminate\Http\Request|null $request
2819: * @return string|null
2820: * @static
2821: */
2822: public static function socket($request = null)
2823: {
2824: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2825: return $instance->socket($request);
2826: }
2827: /**
2828: * Begin broadcasting an event.
2829: *
2830: * @param mixed|null $event
2831: * @return \Illuminate\Broadcasting\PendingBroadcast
2832: * @static
2833: */
2834: public static function event($event = null)
2835: {
2836: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2837: return $instance->event($event);
2838: }
2839: /**
2840: * Queue the given event for broadcast.
2841: *
2842: * @param mixed $event
2843: * @return void
2844: * @static
2845: */
2846: public static function queue($event)
2847: {
2848: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2849: $instance->queue($event);
2850: }
2851: /**
2852: * Get a driver instance.
2853: *
2854: * @param string|null $driver
2855: * @return mixed
2856: * @static
2857: */
2858: public static function connection($driver = null)
2859: {
2860: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2861: return $instance->connection($driver);
2862: }
2863: /**
2864: * Get a driver instance.
2865: *
2866: * @param string|null $name
2867: * @return mixed
2868: * @static
2869: */
2870: public static function driver($name = null)
2871: {
2872: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2873: return $instance->driver($name);
2874: }
2875: /**
2876: * Get a Pusher instance for the given configuration.
2877: *
2878: * @param array $config
2879: * @return \Pusher\Pusher
2880: * @static
2881: */
2882: public static function pusher($config)
2883: {
2884: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2885: return $instance->pusher($config);
2886: }
2887: /**
2888: * Get an Ably instance for the given configuration.
2889: *
2890: * @param array $config
2891: * @return \Ably\AblyRest
2892: * @static
2893: */
2894: public static function ably($config)
2895: {
2896: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2897: return $instance->ably($config);
2898: }
2899: /**
2900: * Get the default driver name.
2901: *
2902: * @return string
2903: * @static
2904: */
2905: public static function getDefaultDriver()
2906: {
2907: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2908: return $instance->getDefaultDriver();
2909: }
2910: /**
2911: * Set the default driver name.
2912: *
2913: * @param string $name
2914: * @return void
2915: * @static
2916: */
2917: public static function setDefaultDriver($name)
2918: {
2919: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2920: $instance->setDefaultDriver($name);
2921: }
2922: /**
2923: * Disconnect the given disk and remove from local cache.
2924: *
2925: * @param string|null $name
2926: * @return void
2927: * @static
2928: */
2929: public static function purge($name = null)
2930: {
2931: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2932: $instance->purge($name);
2933: }
2934: /**
2935: * Register a custom driver creator Closure.
2936: *
2937: * @param string $driver
2938: * @param \Closure $callback
2939: * @return \Illuminate\Broadcasting\BroadcastManager
2940: * @static
2941: */
2942: public static function extend($driver, $callback)
2943: {
2944: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2945: return $instance->extend($driver, $callback);
2946: }
2947: /**
2948: * Get the application instance used by the manager.
2949: *
2950: * @return \Illuminate\Contracts\Foundation\Application
2951: * @static
2952: */
2953: public static function getApplication()
2954: {
2955: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2956: return $instance->getApplication();
2957: }
2958: /**
2959: * Set the application instance used by the manager.
2960: *
2961: * @param \Illuminate\Contracts\Foundation\Application $app
2962: * @return \Illuminate\Broadcasting\BroadcastManager
2963: * @static
2964: */
2965: public static function setApplication($app)
2966: {
2967: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2968: return $instance->setApplication($app);
2969: }
2970: /**
2971: * Forget all of the resolved driver instances.
2972: *
2973: * @return \Illuminate\Broadcasting\BroadcastManager
2974: * @static
2975: */
2976: public static function forgetDrivers()
2977: {
2978: /** @var \Illuminate\Broadcasting\BroadcastManager $instance */
2979: return $instance->forgetDrivers();
2980: }
2981:
2982: }
2983: /**
2984: *
2985: *
2986: * @see \Illuminate\Contracts\Bus\Dispatcher
2987: */
2988: class Bus {
2989: /**
2990: * Dispatch a command to its appropriate handler.
2991: *
2992: * @param mixed $command
2993: * @return mixed
2994: * @static
2995: */
2996: public static function dispatch($command)
2997: {
2998: /** @var \Illuminate\Bus\Dispatcher $instance */
2999: return $instance->dispatch($command);
3000: }
3001: /**
3002: * Dispatch a command to its appropriate handler in the current process.
3003: *
3004: * Queueable jobs will be dispatched to the "sync" queue.
3005: *
3006: * @param mixed $command
3007: * @param mixed $handler
3008: * @return mixed
3009: * @static
3010: */
3011: public static function dispatchSync($command, $handler = null)
3012: {
3013: /** @var \Illuminate\Bus\Dispatcher $instance */
3014: return $instance->dispatchSync($command, $handler);
3015: }
3016: /**
3017: * Dispatch a command to its appropriate handler in the current process without using the synchronous queue.
3018: *
3019: * @param mixed $command
3020: * @param mixed $handler
3021: * @return mixed
3022: * @static
3023: */
3024: public static function dispatchNow($command, $handler = null)
3025: {
3026: /** @var \Illuminate\Bus\Dispatcher $instance */
3027: return $instance->dispatchNow($command, $handler);
3028: }
3029: /**
3030: * Attempt to find the batch with the given ID.
3031: *
3032: * @param string $batchId
3033: * @return \Illuminate\Bus\Batch|null
3034: * @static
3035: */
3036: public static function findBatch($batchId)
3037: {
3038: /** @var \Illuminate\Bus\Dispatcher $instance */
3039: return $instance->findBatch($batchId);
3040: }
3041: /**
3042: * Create a new batch of queueable jobs.
3043: *
3044: * @param \Illuminate\Support\Collection|array|mixed $jobs
3045: * @return \Illuminate\Bus\PendingBatch
3046: * @static
3047: */
3048: public static function batch($jobs)
3049: {
3050: /** @var \Illuminate\Bus\Dispatcher $instance */
3051: return $instance->batch($jobs);
3052: }
3053: /**
3054: * Create a new chain of queueable jobs.
3055: *
3056: * @param \Illuminate\Support\Collection|array $jobs
3057: * @return \Illuminate\Foundation\Bus\PendingChain
3058: * @static
3059: */
3060: public static function chain($jobs)
3061: {
3062: /** @var \Illuminate\Bus\Dispatcher $instance */
3063: return $instance->chain($jobs);
3064: }
3065: /**
3066: * Determine if the given command has a handler.
3067: *
3068: * @param mixed $command
3069: * @return bool
3070: * @static
3071: */
3072: public static function hasCommandHandler($command)
3073: {
3074: /** @var \Illuminate\Bus\Dispatcher $instance */
3075: return $instance->hasCommandHandler($command);
3076: }
3077: /**
3078: * Retrieve the handler for a command.
3079: *
3080: * @param mixed $command
3081: * @return bool|mixed
3082: * @static
3083: */
3084: public static function getCommandHandler($command)
3085: {
3086: /** @var \Illuminate\Bus\Dispatcher $instance */
3087: return $instance->getCommandHandler($command);
3088: }
3089: /**
3090: * Dispatch a command to its appropriate handler behind a queue.
3091: *
3092: * @param mixed $command
3093: * @return mixed
3094: * @throws \RuntimeException
3095: * @static
3096: */
3097: public static function dispatchToQueue($command)
3098: {
3099: /** @var \Illuminate\Bus\Dispatcher $instance */
3100: return $instance->dispatchToQueue($command);
3101: }
3102: /**
3103: * Dispatch a command to its appropriate handler after the current process.
3104: *
3105: * @param mixed $command
3106: * @param mixed $handler
3107: * @return void
3108: * @static
3109: */
3110: public static function dispatchAfterResponse($command, $handler = null)
3111: {
3112: /** @var \Illuminate\Bus\Dispatcher $instance */
3113: $instance->dispatchAfterResponse($command, $handler);
3114: }
3115: /**
3116: * Set the pipes through which commands should be piped before dispatching.
3117: *
3118: * @param array $pipes
3119: * @return \Illuminate\Bus\Dispatcher
3120: * @static
3121: */
3122: public static function pipeThrough($pipes)
3123: {
3124: /** @var \Illuminate\Bus\Dispatcher $instance */
3125: return $instance->pipeThrough($pipes);
3126: }
3127: /**
3128: * Map a command to a handler.
3129: *
3130: * @param array $map
3131: * @return \Illuminate\Bus\Dispatcher
3132: * @static
3133: */
3134: public static function map($map)
3135: {
3136: /** @var \Illuminate\Bus\Dispatcher $instance */
3137: return $instance->map($map);
3138: }
3139: /**
3140: * Assert if a job was dispatched based on a truth-test callback.
3141: *
3142: * @param string|\Closure $command
3143: * @param callable|int|null $callback
3144: * @return void
3145: * @static
3146: */
3147: public static function assertDispatched($command, $callback = null)
3148: {
3149: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3150: $instance->assertDispatched($command, $callback);
3151: }
3152: /**
3153: * Assert if a job was pushed a number of times.
3154: *
3155: * @param string $command
3156: * @param int $times
3157: * @return void
3158: * @static
3159: */
3160: public static function assertDispatchedTimes($command, $times = 1)
3161: {
3162: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3163: $instance->assertDispatchedTimes($command, $times);
3164: }
3165: /**
3166: * Determine if a job was dispatched based on a truth-test callback.
3167: *
3168: * @param string|\Closure $command
3169: * @param callable|null $callback
3170: * @return void
3171: * @static
3172: */
3173: public static function assertNotDispatched($command, $callback = null)
3174: {
3175: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3176: $instance->assertNotDispatched($command, $callback);
3177: }
3178: /**
3179: * Assert that no jobs were dispatched.
3180: *
3181: * @return void
3182: * @static
3183: */
3184: public static function assertNothingDispatched()
3185: {
3186: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3187: $instance->assertNothingDispatched();
3188: }
3189: /**
3190: * Assert if a job was explicitly dispatched synchronously based on a truth-test callback.
3191: *
3192: * @param string|\Closure $command
3193: * @param callable|int|null $callback
3194: * @return void
3195: * @static
3196: */
3197: public static function assertDispatchedSync($command, $callback = null)
3198: {
3199: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3200: $instance->assertDispatchedSync($command, $callback);
3201: }
3202: /**
3203: * Assert if a job was pushed synchronously a number of times.
3204: *
3205: * @param string $command
3206: * @param int $times
3207: * @return void
3208: * @static
3209: */
3210: public static function assertDispatchedSyncTimes($command, $times = 1)
3211: {
3212: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3213: $instance->assertDispatchedSyncTimes($command, $times);
3214: }
3215: /**
3216: * Determine if a job was dispatched based on a truth-test callback.
3217: *
3218: * @param string|\Closure $command
3219: * @param callable|null $callback
3220: * @return void
3221: * @static
3222: */
3223: public static function assertNotDispatchedSync($command, $callback = null)
3224: {
3225: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3226: $instance->assertNotDispatchedSync($command, $callback);
3227: }
3228: /**
3229: * Assert if a job was dispatched after the response was sent based on a truth-test callback.
3230: *
3231: * @param string|\Closure $command
3232: * @param callable|int|null $callback
3233: * @return void
3234: * @static
3235: */
3236: public static function assertDispatchedAfterResponse($command, $callback = null)
3237: {
3238: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3239: $instance->assertDispatchedAfterResponse($command, $callback);
3240: }
3241: /**
3242: * Assert if a job was pushed after the response was sent a number of times.
3243: *
3244: * @param string $command
3245: * @param int $times
3246: * @return void
3247: * @static
3248: */
3249: public static function assertDispatchedAfterResponseTimes($command, $times = 1)
3250: {
3251: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3252: $instance->assertDispatchedAfterResponseTimes($command, $times);
3253: }
3254: /**
3255: * Determine if a job was dispatched based on a truth-test callback.
3256: *
3257: * @param string|\Closure $command
3258: * @param callable|null $callback
3259: * @return void
3260: * @static
3261: */
3262: public static function assertNotDispatchedAfterResponse($command, $callback = null)
3263: {
3264: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3265: $instance->assertNotDispatchedAfterResponse($command, $callback);
3266: }
3267: /**
3268: * Assert if a chain of jobs was dispatched.
3269: *
3270: * @param array $expectedChain
3271: * @return void
3272: * @static
3273: */
3274: public static function assertChained($expectedChain)
3275: {
3276: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3277: $instance->assertChained($expectedChain);
3278: }
3279: /**
3280: * Assert if a job was dispatched with an empty chain based on a truth-test callback.
3281: *
3282: * @param string|\Closure $command
3283: * @param callable|null $callback
3284: * @return void
3285: * @static
3286: */
3287: public static function assertDispatchedWithoutChain($command, $callback = null)
3288: {
3289: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3290: $instance->assertDispatchedWithoutChain($command, $callback);
3291: }
3292: /**
3293: * Assert if a batch was dispatched based on a truth-test callback.
3294: *
3295: * @param callable $callback
3296: * @return void
3297: * @static
3298: */
3299: public static function assertBatched($callback)
3300: {
3301: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3302: $instance->assertBatched($callback);
3303: }
3304: /**
3305: * Assert the number of batches that have been dispatched.
3306: *
3307: * @param int $count
3308: * @return void
3309: * @static
3310: */
3311: public static function assertBatchCount($count)
3312: {
3313: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3314: $instance->assertBatchCount($count);
3315: }
3316: /**
3317: * Get all of the jobs matching a truth-test callback.
3318: *
3319: * @param string $command
3320: * @param callable|null $callback
3321: * @return \Illuminate\Support\Collection
3322: * @static
3323: */
3324: public static function dispatched($command, $callback = null)
3325: {
3326: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3327: return $instance->dispatched($command, $callback);
3328: }
3329: /**
3330: * Get all of the jobs dispatched synchronously matching a truth-test callback.
3331: *
3332: * @param string $command
3333: * @param callable|null $callback
3334: * @return \Illuminate\Support\Collection
3335: * @static
3336: */
3337: public static function dispatchedSync($command, $callback = null)
3338: {
3339: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3340: return $instance->dispatchedSync($command, $callback);
3341: }
3342: /**
3343: * Get all of the jobs dispatched after the response was sent matching a truth-test callback.
3344: *
3345: * @param string $command
3346: * @param callable|null $callback
3347: * @return \Illuminate\Support\Collection
3348: * @static
3349: */
3350: public static function dispatchedAfterResponse($command, $callback = null)
3351: {
3352: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3353: return $instance->dispatchedAfterResponse($command, $callback);
3354: }
3355: /**
3356: * Get all of the pending batches matching a truth-test callback.
3357: *
3358: * @param callable $callback
3359: * @return \Illuminate\Support\Collection
3360: * @static
3361: */
3362: public static function batched($callback)
3363: {
3364: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3365: return $instance->batched($callback);
3366: }
3367: /**
3368: * Determine if there are any stored commands for a given class.
3369: *
3370: * @param string $command
3371: * @return bool
3372: * @static
3373: */
3374: public static function hasDispatched($command)
3375: {
3376: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3377: return $instance->hasDispatched($command);
3378: }
3379: /**
3380: * Determine if there are any stored commands for a given class.
3381: *
3382: * @param string $command
3383: * @return bool
3384: * @static
3385: */
3386: public static function hasDispatchedSync($command)
3387: {
3388: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3389: return $instance->hasDispatchedSync($command);
3390: }
3391: /**
3392: * Determine if there are any stored commands for a given class.
3393: *
3394: * @param string $command
3395: * @return bool
3396: * @static
3397: */
3398: public static function hasDispatchedAfterResponse($command)
3399: {
3400: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3401: return $instance->hasDispatchedAfterResponse($command);
3402: }
3403: /**
3404: * Record the fake pending batch dispatch.
3405: *
3406: * @param \Illuminate\Bus\PendingBatch $pendingBatch
3407: * @return \Illuminate\Bus\Batch
3408: * @static
3409: */
3410: public static function recordPendingBatch($pendingBatch)
3411: {
3412: /** @var \Illuminate\Support\Testing\Fakes\BusFake $instance */
3413: return $instance->recordPendingBatch($pendingBatch);
3414: }
3415:
3416: }
3417: /**
3418: *
3419: *
3420: * @see \Illuminate\Cache\CacheManager
3421: * @see \Illuminate\Cache\Repository
3422: */
3423: class Cache {
3424: /**
3425: * Get a cache store instance by name, wrapped in a repository.
3426: *
3427: * @param string|null $name
3428: * @return \Illuminate\Contracts\Cache\Repository
3429: * @static
3430: */
3431: public static function store($name = null)
3432: {
3433: /** @var \Illuminate\Cache\CacheManager $instance */
3434: return $instance->store($name);
3435: }
3436: /**
3437: * Get a cache driver instance.
3438: *
3439: * @param string|null $driver
3440: * @return \Illuminate\Contracts\Cache\Repository
3441: * @static
3442: */
3443: public static function driver($driver = null)
3444: {
3445: /** @var \Illuminate\Cache\CacheManager $instance */
3446: return $instance->driver($driver);
3447: }
3448: /**
3449: * Create a new cache repository with the given implementation.
3450: *
3451: * @param \Illuminate\Contracts\Cache\Store $store
3452: * @return \Illuminate\Cache\Repository
3453: * @static
3454: */
3455: public static function repository($store)
3456: {
3457: /** @var \Illuminate\Cache\CacheManager $instance */
3458: return $instance->repository($store);
3459: }
3460: /**
3461: * Re-set the event dispatcher on all resolved cache repositories.
3462: *
3463: * @return void
3464: * @static
3465: */
3466: public static function refreshEventDispatcher()
3467: {
3468: /** @var \Illuminate\Cache\CacheManager $instance */
3469: $instance->refreshEventDispatcher();
3470: }
3471: /**
3472: * Get the default cache driver name.
3473: *
3474: * @return string
3475: * @static
3476: */
3477: public static function getDefaultDriver()
3478: {
3479: /** @var \Illuminate\Cache\CacheManager $instance */
3480: return $instance->getDefaultDriver();
3481: }
3482: /**
3483: * Set the default cache driver name.
3484: *
3485: * @param string $name
3486: * @return void
3487: * @static
3488: */
3489: public static function setDefaultDriver($name)
3490: {
3491: /** @var \Illuminate\Cache\CacheManager $instance */
3492: $instance->setDefaultDriver($name);
3493: }
3494: /**
3495: * Unset the given driver instances.
3496: *
3497: * @param array|string|null $name
3498: * @return \Illuminate\Cache\CacheManager
3499: * @static
3500: */
3501: public static function forgetDriver($name = null)
3502: {
3503: /** @var \Illuminate\Cache\CacheManager $instance */
3504: return $instance->forgetDriver($name);
3505: }
3506: /**
3507: * Disconnect the given driver and remove from local cache.
3508: *
3509: * @param string|null $name
3510: * @return void
3511: * @static
3512: */
3513: public static function purge($name = null)
3514: {
3515: /** @var \Illuminate\Cache\CacheManager $instance */
3516: $instance->purge($name);
3517: }
3518: /**
3519: * Register a custom driver creator Closure.
3520: *
3521: * @param string $driver
3522: * @param \Closure $callback
3523: * @return \Illuminate\Cache\CacheManager
3524: * @static
3525: */
3526: public static function extend($driver, $callback)
3527: {
3528: /** @var \Illuminate\Cache\CacheManager $instance */
3529: return $instance->extend($driver, $callback);
3530: }
3531: /**
3532: * Determine if an item exists in the cache.
3533: *
3534: * @param string $key
3535: * @return bool
3536: * @static
3537: */
3538: public static function has($key)
3539: {
3540: /** @var \Illuminate\Cache\Repository $instance */
3541: return $instance->has($key);
3542: }
3543: /**
3544: * Determine if an item doesn't exist in the cache.
3545: *
3546: * @param string $key
3547: * @return bool
3548: * @static
3549: */
3550: public static function missing($key)
3551: {
3552: /** @var \Illuminate\Cache\Repository $instance */
3553: return $instance->missing($key);
3554: }
3555: /**
3556: * Retrieve an item from the cache by key.
3557: *
3558: * @param array|string $key
3559: * @param mixed $default
3560: * @return mixed
3561: * @static
3562: */
3563: public static function get($key, $default = null)
3564: {
3565: /** @var \Illuminate\Cache\Repository $instance */
3566: return $instance->get($key, $default);
3567: }
3568: /**
3569: * Retrieve multiple items from the cache by key.
3570: *
3571: * Items not found in the cache will have a null value.
3572: *
3573: * @param array $keys
3574: * @return array
3575: * @static
3576: */
3577: public static function many($keys)
3578: {
3579: /** @var \Illuminate\Cache\Repository $instance */
3580: return $instance->many($keys);
3581: }
3582: /**
3583: * Obtains multiple cache items by their unique keys.
3584: *
3585: * @return \Illuminate\Cache\iterable
3586: * @param \Psr\SimpleCache\iterable<string> $keys A list of keys that can be obtained in a single operation.
3587: * @param mixed $default Default value to return for keys that do not exist.
3588: * @return \Psr\SimpleCache\iterable<string, mixed> A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value.
3589: * @throws \Psr\SimpleCache\InvalidArgumentException
3590: * MUST be thrown if $keys is neither an array nor a Traversable,
3591: * or if any of the $keys are not a legal value.
3592: * @static
3593: */
3594: public static function getMultiple($keys, $default = null)
3595: {
3596: /** @var \Illuminate\Cache\Repository $instance */
3597: return $instance->getMultiple($keys, $default);
3598: }
3599: /**
3600: * Retrieve an item from the cache and delete it.
3601: *
3602: * @param string $key
3603: * @param mixed $default
3604: * @return mixed
3605: * @static
3606: */
3607: public static function pull($key, $default = null)
3608: {
3609: /** @var \Illuminate\Cache\Repository $instance */
3610: return $instance->pull($key, $default);
3611: }
3612: /**
3613: * Store an item in the cache.
3614: *
3615: * @param array|string $key
3616: * @param mixed $value
3617: * @param \DateTimeInterface|\DateInterval|int|null $ttl
3618: * @return bool
3619: * @static
3620: */
3621: public static function put($key, $value, $ttl = null)
3622: {
3623: /** @var \Illuminate\Cache\Repository $instance */
3624: return $instance->put($key, $value, $ttl);
3625: }
3626: /**
3627: * Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time.
3628: *
3629: * @return bool
3630: * @param string $key The key of the item to store.
3631: * @param mixed $value The value of the item to store, must be serializable.
3632: * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
3633: * the driver supports TTL then the library may set a default value
3634: * for it or let the driver take care of that.
3635: * @return bool True on success and false on failure.
3636: * @throws \Psr\SimpleCache\InvalidArgumentException
3637: * MUST be thrown if the $key string is not a legal value.
3638: * @static
3639: */
3640: public static function set($key, $value, $ttl = null)
3641: {
3642: /** @var \Illuminate\Cache\Repository $instance */
3643: return $instance->set($key, $value, $ttl);
3644: }
3645: /**
3646: * Store multiple items in the cache for a given number of seconds.
3647: *
3648: * @param array $values
3649: * @param \DateTimeInterface|\DateInterval|int|null $ttl
3650: * @return bool
3651: * @static
3652: */
3653: public static function putMany($values, $ttl = null)
3654: {
3655: /** @var \Illuminate\Cache\Repository $instance */
3656: return $instance->putMany($values, $ttl);
3657: }
3658: /**
3659: * Persists a set of key => value pairs in the cache, with an optional TTL.
3660: *
3661: * @return bool
3662: * @param \Psr\SimpleCache\iterable $values A list of key => value pairs for a multiple-set operation.
3663: * @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and
3664: * the driver supports TTL then the library may set a default value
3665: * for it or let the driver take care of that.
3666: * @return bool True on success and false on failure.
3667: * @throws \Psr\SimpleCache\InvalidArgumentException
3668: * MUST be thrown if $values is neither an array nor a Traversable,
3669: * or if any of the $values are not a legal value.
3670: * @static
3671: */
3672: public static function setMultiple($values, $ttl = null)
3673: {
3674: /** @var \Illuminate\Cache\Repository $instance */
3675: return $instance->setMultiple($values, $ttl);
3676: }
3677: /**
3678: * Store an item in the cache if the key does not exist.
3679: *
3680: * @param string $key
3681: * @param mixed $value
3682: * @param \DateTimeInterface|\DateInterval|int|null $ttl
3683: * @return bool
3684: * @static
3685: */
3686: public static function add($key, $value, $ttl = null)
3687: {
3688: /** @var \Illuminate\Cache\Repository $instance */
3689: return $instance->add($key, $value, $ttl);
3690: }
3691: /**
3692: * Increment the value of an item in the cache.
3693: *
3694: * @param string $key
3695: * @param mixed $value
3696: * @return int|bool
3697: * @static
3698: */
3699: public static function increment($key, $value = 1)
3700: {
3701: /** @var \Illuminate\Cache\Repository $instance */
3702: return $instance->increment($key, $value);
3703: }
3704: /**
3705: * Decrement the value of an item in the cache.
3706: *
3707: * @param string $key
3708: * @param mixed $value
3709: * @return int|bool
3710: * @static
3711: */
3712: public static function decrement($key, $value = 1)
3713: {
3714: /** @var \Illuminate\Cache\Repository $instance */
3715: return $instance->decrement($key, $value);
3716: }
3717: /**
3718: * Store an item in the cache indefinitely.
3719: *
3720: * @param string $key
3721: * @param mixed $value
3722: * @return bool
3723: * @static
3724: */
3725: public static function forever($key, $value)
3726: {
3727: /** @var \Illuminate\Cache\Repository $instance */
3728: return $instance->forever($key, $value);
3729: }
3730: /**
3731: * Get an item from the cache, or execute the given Closure and store the result.
3732: *
3733: * @param string $key
3734: * @param \Closure|\DateTimeInterface|\DateInterval|int|null $ttl
3735: * @param \Closure $callback
3736: * @return mixed
3737: * @static
3738: */
3739: public static function remember($key, $ttl, $callback)
3740: {
3741: /** @var \Illuminate\Cache\Repository $instance */
3742: return $instance->remember($key, $ttl, $callback);
3743: }
3744: /**
3745: * Get an item from the cache, or execute the given Closure and store the result forever.
3746: *
3747: * @param string $key
3748: * @param \Closure $callback
3749: * @return mixed
3750: * @static
3751: */
3752: public static function sear($key, $callback)
3753: {
3754: /** @var \Illuminate\Cache\Repository $instance */
3755: return $instance->sear($key, $callback);
3756: }
3757: /**
3758: * Get an item from the cache, or execute the given Closure and store the result forever.
3759: *
3760: * @param string $key
3761: * @param \Closure $callback
3762: * @return mixed
3763: * @static
3764: */
3765: public static function rememberForever($key, $callback)
3766: {
3767: /** @var \Illuminate\Cache\Repository $instance */
3768: return $instance->rememberForever($key, $callback);
3769: }
3770: /**
3771: * Remove an item from the cache.
3772: *
3773: * @param string $key
3774: * @return bool
3775: * @static
3776: */
3777: public static function forget($key)
3778: {
3779: /** @var \Illuminate\Cache\Repository $instance */
3780: return $instance->forget($key);
3781: }
3782: /**
3783: * Delete an item from the cache by its unique key.
3784: *
3785: * @return bool
3786: * @param string $key The unique cache key of the item to delete.
3787: * @return bool True if the item was successfully removed. False if there was an error.
3788: * @throws \Psr\SimpleCache\InvalidArgumentException
3789: * MUST be thrown if the $key string is not a legal value.
3790: * @static
3791: */
3792: public static function delete($key)
3793: {
3794: /** @var \Illuminate\Cache\Repository $instance */
3795: return $instance->delete($key);
3796: }
3797: /**
3798: * Deletes multiple cache items in a single operation.
3799: *
3800: * @return bool
3801: * @param \Psr\SimpleCache\iterable<string> $keys A list of string-based keys to be deleted.
3802: * @return bool True if the items were successfully removed. False if there was an error.
3803: * @throws \Psr\SimpleCache\InvalidArgumentException
3804: * MUST be thrown if $keys is neither an array nor a Traversable,
3805: * or if any of the $keys are not a legal value.
3806: * @static
3807: */
3808: public static function deleteMultiple($keys)
3809: {
3810: /** @var \Illuminate\Cache\Repository $instance */
3811: return $instance->deleteMultiple($keys);
3812: }
3813: /**
3814: * Wipes clean the entire cache's keys.
3815: *
3816: * @return bool
3817: * @return bool True on success and false on failure.
3818: * @static
3819: */
3820: public static function clear()
3821: {
3822: /** @var \Illuminate\Cache\Repository $instance */
3823: return $instance->clear();
3824: }
3825: /**
3826: * Begin executing a new tags operation if the store supports it.
3827: *
3828: * @param array|mixed $names
3829: * @return \Illuminate\Cache\TaggedCache
3830: * @throws \BadMethodCallException
3831: * @static
3832: */
3833: public static function tags($names)
3834: {
3835: /** @var \Illuminate\Cache\Repository $instance */
3836: return $instance->tags($names);
3837: }
3838: /**
3839: * Determine if the current store supports tags.
3840: *
3841: * @return bool
3842: * @static
3843: */
3844: public static function supportsTags()
3845: {
3846: /** @var \Illuminate\Cache\Repository $instance */
3847: return $instance->supportsTags();
3848: }
3849: /**
3850: * Get the default cache time.
3851: *
3852: * @return int|null
3853: * @static
3854: */
3855: public static function getDefaultCacheTime()
3856: {
3857: /** @var \Illuminate\Cache\Repository $instance */
3858: return $instance->getDefaultCacheTime();
3859: }
3860: /**
3861: * Set the default cache time in seconds.
3862: *
3863: * @param int|null $seconds
3864: * @return \Illuminate\Cache\Repository
3865: * @static
3866: */
3867: public static function setDefaultCacheTime($seconds)
3868: {
3869: /** @var \Illuminate\Cache\Repository $instance */
3870: return $instance->setDefaultCacheTime($seconds);
3871: }
3872: /**
3873: * Get the cache store implementation.
3874: *
3875: * @return \Illuminate\Contracts\Cache\Store
3876: * @static
3877: */
3878: public static function getStore()
3879: {
3880: /** @var \Illuminate\Cache\Repository $instance */
3881: return $instance->getStore();
3882: }
3883: /**
3884: * Get the event dispatcher instance.
3885: *
3886: * @return \Illuminate\Contracts\Events\Dispatcher
3887: * @static
3888: */
3889: public static function getEventDispatcher()
3890: {
3891: /** @var \Illuminate\Cache\Repository $instance */
3892: return $instance->getEventDispatcher();
3893: }
3894: /**
3895: * Set the event dispatcher instance.
3896: *
3897: * @param \Illuminate\Contracts\Events\Dispatcher $events
3898: * @return void
3899: * @static
3900: */
3901: public static function setEventDispatcher($events)
3902: {
3903: /** @var \Illuminate\Cache\Repository $instance */
3904: $instance->setEventDispatcher($events);
3905: }
3906: /**
3907: * Determine if a cached value exists.
3908: *
3909: * @param string $key
3910: * @return bool
3911: * @static
3912: */
3913: public static function offsetExists($key)
3914: {
3915: /** @var \Illuminate\Cache\Repository $instance */
3916: return $instance->offsetExists($key);
3917: }
3918: /**
3919: * Retrieve an item from the cache by key.
3920: *
3921: * @param string $key
3922: * @return mixed
3923: * @static
3924: */
3925: public static function offsetGet($key)
3926: {
3927: /** @var \Illuminate\Cache\Repository $instance */
3928: return $instance->offsetGet($key);
3929: }
3930: /**
3931: * Store an item in the cache for the default time.
3932: *
3933: * @param string $key
3934: * @param mixed $value
3935: * @return void
3936: * @static
3937: */
3938: public static function offsetSet($key, $value)
3939: {
3940: /** @var \Illuminate\Cache\Repository $instance */
3941: $instance->offsetSet($key, $value);
3942: }
3943: /**
3944: * Remove an item from the cache.
3945: *
3946: * @param string $key
3947: * @return void
3948: * @static
3949: */
3950: public static function offsetUnset($key)
3951: {
3952: /** @var \Illuminate\Cache\Repository $instance */
3953: $instance->offsetUnset($key);
3954: }
3955: /**
3956: * Register a custom macro.
3957: *
3958: * @param string $name
3959: * @param object|callable $macro
3960: * @return void
3961: * @static
3962: */
3963: public static function macro($name, $macro)
3964: {
3965: \Illuminate\Cache\Repository::macro($name, $macro);
3966: }
3967: /**
3968: * Mix another object into the class.
3969: *
3970: * @param object $mixin
3971: * @param bool $replace
3972: * @return void
3973: * @throws \ReflectionException
3974: * @static
3975: */
3976: public static function mixin($mixin, $replace = true)
3977: {
3978: \Illuminate\Cache\Repository::mixin($mixin, $replace);
3979: }
3980: /**
3981: * Checks if macro is registered.
3982: *
3983: * @param string $name
3984: * @return bool
3985: * @static
3986: */
3987: public static function hasMacro($name)
3988: {
3989: return \Illuminate\Cache\Repository::hasMacro($name);
3990: }
3991: /**
3992: * Flush the existing macros.
3993: *
3994: * @return void
3995: * @static
3996: */
3997: public static function flushMacros()
3998: {
3999: \Illuminate\Cache\Repository::flushMacros();
4000: }
4001: /**
4002: * Dynamically handle calls to the class.
4003: *
4004: * @param string $method
4005: * @param array $parameters
4006: * @return mixed
4007: * @throws \BadMethodCallException
4008: * @static
4009: */
4010: public static function macroCall($method, $parameters)
4011: {
4012: /** @var \Illuminate\Cache\Repository $instance */
4013: return $instance->macroCall($method, $parameters);
4014: }
4015: /**
4016: * Remove all items from the cache.
4017: *
4018: * @return bool
4019: * @static
4020: */
4021: public static function flush()
4022: {
4023: /** @var \Illuminate\Cache\FileStore $instance */
4024: return $instance->flush();
4025: }
4026: /**
4027: * Get the Filesystem instance.
4028: *
4029: * @return \Illuminate\Filesystem\Filesystem
4030: * @static
4031: */
4032: public static function getFilesystem()
4033: {
4034: /** @var \Illuminate\Cache\FileStore $instance */
4035: return $instance->getFilesystem();
4036: }
4037: /**
4038: * Get the working directory of the cache.
4039: *
4040: * @return string
4041: * @static
4042: */
4043: public static function getDirectory()
4044: {
4045: /** @var \Illuminate\Cache\FileStore $instance */
4046: return $instance->getDirectory();
4047: }
4048: /**
4049: * Get the cache key prefix.
4050: *
4051: * @return string
4052: * @static
4053: */
4054: public static function getPrefix()
4055: {
4056: /** @var \Illuminate\Cache\FileStore $instance */
4057: return $instance->getPrefix();
4058: }
4059: /**
4060: * Get a lock instance.
4061: *
4062: * @param string $name
4063: * @param int $seconds
4064: * @param string|null $owner
4065: * @return \Illuminate\Contracts\Cache\Lock
4066: * @static
4067: */
4068: public static function lock($name, $seconds = 0, $owner = null)
4069: {
4070: /** @var \Illuminate\Cache\FileStore $instance */
4071: return $instance->lock($name, $seconds, $owner);
4072: }
4073: /**
4074: * Restore a lock instance using the owner identifier.
4075: *
4076: * @param string $name
4077: * @param string $owner
4078: * @return \Illuminate\Contracts\Cache\Lock
4079: * @static
4080: */
4081: public static function restoreLock($name, $owner)
4082: {
4083: /** @var \Illuminate\Cache\FileStore $instance */
4084: return $instance->restoreLock($name, $owner);
4085: }
4086:
4087: }
4088: /**
4089: *
4090: *
4091: * @see \Illuminate\Config\Repository
4092: */
4093: class Config {
4094: /**
4095: * Determine if the given configuration value exists.
4096: *
4097: * @param string $key
4098: * @return bool
4099: * @static
4100: */
4101: public static function has($key)
4102: {
4103: /** @var \Illuminate\Config\Repository $instance */
4104: return $instance->has($key);
4105: }
4106: /**
4107: * Get the specified configuration value.
4108: *
4109: * @param array|string $key
4110: * @param mixed $default
4111: * @return mixed
4112: * @static
4113: */
4114: public static function get($key, $default = null)
4115: {
4116: /** @var \Illuminate\Config\Repository $instance */
4117: return $instance->get($key, $default);
4118: }
4119: /**
4120: * Get many configuration values.
4121: *
4122: * @param array $keys
4123: * @return array
4124: * @static
4125: */
4126: public static function getMany($keys)
4127: {
4128: /** @var \Illuminate\Config\Repository $instance */
4129: return $instance->getMany($keys);
4130: }
4131: /**
4132: * Set a given configuration value.
4133: *
4134: * @param array|string $key
4135: * @param mixed $value
4136: * @return void
4137: * @static
4138: */
4139: public static function set($key, $value = null)
4140: {
4141: /** @var \Illuminate\Config\Repository $instance */
4142: $instance->set($key, $value);
4143: }
4144: /**
4145: * Prepend a value onto an array configuration value.
4146: *
4147: * @param string $key
4148: * @param mixed $value
4149: * @return void
4150: * @static
4151: */
4152: public static function prepend($key, $value)
4153: {
4154: /** @var \Illuminate\Config\Repository $instance */
4155: $instance->prepend($key, $value);
4156: }
4157: /**
4158: * Push a value onto an array configuration value.
4159: *
4160: * @param string $key
4161: * @param mixed $value
4162: * @return void
4163: * @static
4164: */
4165: public static function push($key, $value)
4166: {
4167: /** @var \Illuminate\Config\Repository $instance */
4168: $instance->push($key, $value);
4169: }
4170: /**
4171: * Get all of the configuration items for the application.
4172: *
4173: * @return array
4174: * @static
4175: */
4176: public static function all()
4177: {
4178: /** @var \Illuminate\Config\Repository $instance */
4179: return $instance->all();
4180: }
4181: /**
4182: * Determine if the given configuration option exists.
4183: *
4184: * @param string $key
4185: * @return bool
4186: * @static
4187: */
4188: public static function offsetExists($key)
4189: {
4190: /** @var \Illuminate\Config\Repository $instance */
4191: return $instance->offsetExists($key);
4192: }
4193: /**
4194: * Get a configuration option.
4195: *
4196: * @param string $key
4197: * @return mixed
4198: * @static
4199: */
4200: public static function offsetGet($key)
4201: {
4202: /** @var \Illuminate\Config\Repository $instance */
4203: return $instance->offsetGet($key);
4204: }
4205: /**
4206: * Set a configuration option.
4207: *
4208: * @param string $key
4209: * @param mixed $value
4210: * @return void
4211: * @static
4212: */
4213: public static function offsetSet($key, $value)
4214: {
4215: /** @var \Illuminate\Config\Repository $instance */
4216: $instance->offsetSet($key, $value);
4217: }
4218: /**
4219: * Unset a configuration option.
4220: *
4221: * @param string $key
4222: * @return void
4223: * @static
4224: */
4225: public static function offsetUnset($key)
4226: {
4227: /** @var \Illuminate\Config\Repository $instance */
4228: $instance->offsetUnset($key);
4229: }
4230:
4231: }
4232: /**
4233: *
4234: *
4235: * @see \Illuminate\Cookie\CookieJar
4236: */
4237: class Cookie {
4238: /**
4239: * Create a new cookie instance.
4240: *
4241: * @param string $name
4242: * @param string $value
4243: * @param int $minutes
4244: * @param string|null $path
4245: * @param string|null $domain
4246: * @param bool|null $secure
4247: * @param bool $httpOnly
4248: * @param bool $raw
4249: * @param string|null $sameSite
4250: * @return \Symfony\Component\HttpFoundation\Cookie
4251: * @static
4252: */
4253: public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
4254: {
4255: /** @var \Illuminate\Cookie\CookieJar $instance */
4256: return $instance->make($name, $value, $minutes, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
4257: }
4258: /**
4259: * Create a cookie that lasts "forever" (five years).
4260: *
4261: * @param string $name
4262: * @param string $value
4263: * @param string|null $path
4264: * @param string|null $domain
4265: * @param bool|null $secure
4266: * @param bool $httpOnly
4267: * @param bool $raw
4268: * @param string|null $sameSite
4269: * @return \Symfony\Component\HttpFoundation\Cookie
4270: * @static
4271: */
4272: public static function forever($name, $value, $path = null, $domain = null, $secure = null, $httpOnly = true, $raw = false, $sameSite = null)
4273: {
4274: /** @var \Illuminate\Cookie\CookieJar $instance */
4275: return $instance->forever($name, $value, $path, $domain, $secure, $httpOnly, $raw, $sameSite);
4276: }
4277: /**
4278: * Expire the given cookie.
4279: *
4280: * @param string $name
4281: * @param string|null $path
4282: * @param string|null $domain
4283: * @return \Symfony\Component\HttpFoundation\Cookie
4284: * @static
4285: */
4286: public static function forget($name, $path = null, $domain = null)
4287: {
4288: /** @var \Illuminate\Cookie\CookieJar $instance */
4289: return $instance->forget($name, $path, $domain);
4290: }
4291: /**
4292: * Determine if a cookie has been queued.
4293: *
4294: * @param string $key
4295: * @param string|null $path
4296: * @return bool
4297: * @static
4298: */
4299: public static function hasQueued($key, $path = null)
4300: {
4301: /** @var \Illuminate\Cookie\CookieJar $instance */
4302: return $instance->hasQueued($key, $path);
4303: }
4304: /**
4305: * Get a queued cookie instance.
4306: *
4307: * @param string $key
4308: * @param mixed $default
4309: * @param string|null $path
4310: * @return \Symfony\Component\HttpFoundation\Cookie|null
4311: * @static
4312: */
4313: public static function queued($key, $default = null, $path = null)
4314: {
4315: /** @var \Illuminate\Cookie\CookieJar $instance */
4316: return $instance->queued($key, $default, $path);
4317: }
4318: /**
4319: * Queue a cookie to send with the next response.
4320: *
4321: * @param array $parameters
4322: * @return void
4323: * @static
4324: */
4325: public static function queue(...$parameters)
4326: {
4327: /** @var \Illuminate\Cookie\CookieJar $instance */
4328: $instance->queue(...$parameters);
4329: }
4330: /**
4331: * Queue a cookie to expire with the next response.
4332: *
4333: * @param string $name
4334: * @param string|null $path
4335: * @param string|null $domain
4336: * @return void
4337: * @static
4338: */
4339: public static function expire($name, $path = null, $domain = null)
4340: {
4341: /** @var \Illuminate\Cookie\CookieJar $instance */
4342: $instance->expire($name, $path, $domain);
4343: }
4344: /**
4345: * Remove a cookie from the queue.
4346: *
4347: * @param string $name
4348: * @param string|null $path
4349: * @return void
4350: * @static
4351: */
4352: public static function unqueue($name, $path = null)
4353: {
4354: /** @var \Illuminate\Cookie\CookieJar $instance */
4355: $instance->unqueue($name, $path);
4356: }
4357: /**
4358: * Set the default path and domain for the jar.
4359: *
4360: * @param string $path
4361: * @param string $domain
4362: * @param bool $secure
4363: * @param string|null $sameSite
4364: * @return \Illuminate\Cookie\CookieJar
4365: * @static
4366: */
4367: public static function setDefaultPathAndDomain($path, $domain, $secure = false, $sameSite = null)
4368: {
4369: /** @var \Illuminate\Cookie\CookieJar $instance */
4370: return $instance->setDefaultPathAndDomain($path, $domain, $secure, $sameSite);
4371: }
4372: /**
4373: * Get the cookies which have been queued for the next request.
4374: *
4375: * @return \Symfony\Component\HttpFoundation\Cookie[]
4376: * @static
4377: */
4378: public static function getQueuedCookies()
4379: {
4380: /** @var \Illuminate\Cookie\CookieJar $instance */
4381: return $instance->getQueuedCookies();
4382: }
4383: /**
4384: * Flush the cookies which have been queued for the next request.
4385: *
4386: * @return \Illuminate\Cookie\CookieJar
4387: * @static
4388: */
4389: public static function flushQueuedCookies()
4390: {
4391: /** @var \Illuminate\Cookie\CookieJar $instance */
4392: return $instance->flushQueuedCookies();
4393: }
4394: /**
4395: * Register a custom macro.
4396: *
4397: * @param string $name
4398: * @param object|callable $macro
4399: * @return void
4400: * @static
4401: */
4402: public static function macro($name, $macro)
4403: {
4404: \Illuminate\Cookie\CookieJar::macro($name, $macro);
4405: }
4406: /**
4407: * Mix another object into the class.
4408: *
4409: * @param object $mixin
4410: * @param bool $replace
4411: * @return void
4412: * @throws \ReflectionException
4413: * @static
4414: */
4415: public static function mixin($mixin, $replace = true)
4416: {
4417: \Illuminate\Cookie\CookieJar::mixin($mixin, $replace);
4418: }
4419: /**
4420: * Checks if macro is registered.
4421: *
4422: * @param string $name
4423: * @return bool
4424: * @static
4425: */
4426: public static function hasMacro($name)
4427: {
4428: return \Illuminate\Cookie\CookieJar::hasMacro($name);
4429: }
4430: /**
4431: * Flush the existing macros.
4432: *
4433: * @return void
4434: * @static
4435: */
4436: public static function flushMacros()
4437: {
4438: \Illuminate\Cookie\CookieJar::flushMacros();
4439: }
4440:
4441: }
4442: /**
4443: *
4444: *
4445: * @see \Illuminate\Encryption\Encrypter
4446: */
4447: class Crypt {
4448: /**
4449: * Determine if the given key and cipher combination is valid.
4450: *
4451: * @param string $key
4452: * @param string $cipher
4453: * @return bool
4454: * @static
4455: */
4456: public static function supported($key, $cipher)
4457: {
4458: return \Illuminate\Encryption\Encrypter::supported($key, $cipher);
4459: }
4460: /**
4461: * Create a new encryption key for the given cipher.
4462: *
4463: * @param string $cipher
4464: * @return string
4465: * @static
4466: */
4467: public static function generateKey($cipher)
4468: {
4469: return \Illuminate\Encryption\Encrypter::generateKey($cipher);
4470: }
4471: /**
4472: * Encrypt the given value.
4473: *
4474: * @param mixed $value
4475: * @param bool $serialize
4476: * @return string
4477: * @throws \Illuminate\Contracts\Encryption\EncryptException
4478: * @static
4479: */
4480: public static function encrypt($value, $serialize = true)
4481: {
4482: /** @var \Illuminate\Encryption\Encrypter $instance */
4483: return $instance->encrypt($value, $serialize);
4484: }
4485: /**
4486: * Encrypt a string without serialization.
4487: *
4488: * @param string $value
4489: * @return string
4490: * @throws \Illuminate\Contracts\Encryption\EncryptException
4491: * @static
4492: */
4493: public static function encryptString($value)
4494: {
4495: /** @var \Illuminate\Encryption\Encrypter $instance */
4496: return $instance->encryptString($value);
4497: }
4498: /**
4499: * Decrypt the given value.
4500: *
4501: * @param string $payload
4502: * @param bool $unserialize
4503: * @return mixed
4504: * @throws \Illuminate\Contracts\Encryption\DecryptException
4505: * @static
4506: */
4507: public static function decrypt($payload, $unserialize = true)
4508: {
4509: /** @var \Illuminate\Encryption\Encrypter $instance */
4510: return $instance->decrypt($payload, $unserialize);
4511: }
4512: /**
4513: * Decrypt the given string without unserialization.
4514: *
4515: * @param string $payload
4516: * @return string
4517: * @throws \Illuminate\Contracts\Encryption\DecryptException
4518: * @static
4519: */
4520: public static function decryptString($payload)
4521: {
4522: /** @var \Illuminate\Encryption\Encrypter $instance */
4523: return $instance->decryptString($payload);
4524: }
4525: /**
4526: * Get the encryption key that the encrypter is currently using.
4527: *
4528: * @return string
4529: * @static
4530: */
4531: public static function getKey()
4532: {
4533: /** @var \Illuminate\Encryption\Encrypter $instance */
4534: return $instance->getKey();
4535: }
4536:
4537: }
4538: /**
4539: *
4540: *
4541: * @see https://carbon.nesbot.com/docs/
4542: * @see https://github.com/briannesbitt/Carbon/blob/master/src/Carbon/Factory.php
4543: * @method static \Illuminate\Support\Carbon create($year = 0, $month = 1, $day = 1, $hour = 0, $minute = 0, $second = 0, $tz = null)
4544: * @method static \Illuminate\Support\Carbon createFromDate($year = null, $month = null, $day = null, $tz = null)
4545: * @method static \Illuminate\Support\Carbon createFromTime($hour = 0, $minute = 0, $second = 0, $tz = null)
4546: * @method static \Illuminate\Support\Carbon createFromTimeString($time, $tz = null)
4547: * @method static \Illuminate\Support\Carbon createFromTimestamp($timestamp, $tz = null)
4548: * @method static \Illuminate\Support\Carbon createFromTimestampMs($timestamp, $tz = null)
4549: * @method static \Illuminate\Support\Carbon createFromTimestampUTC($timestamp)
4550: * @method static \Illuminate\Support\Carbon createMidnightDate($year = null, $month = null, $day = null, $tz = null)
4551: * @method static void disableHumanDiffOption($humanDiffOption)
4552: * @method static void enableHumanDiffOption($humanDiffOption)
4553: * @method static \Illuminate\Support\Carbon fromSerialized($value)
4554: * @method static array getLastErrors()
4555: * @method static \Illuminate\Support\Carbon|null getTestNow()
4556: * @method static \Illuminate\Support\Carbon instance($date)
4557: * @method static bool isMutable()
4558: * @method static \Illuminate\Support\Carbon maxValue()
4559: * @method static \Illuminate\Support\Carbon minValue()
4560: * @method static \Illuminate\Support\Carbon now($tz = null)
4561: * @method static \Illuminate\Support\Carbon parse($time = null, $tz = null)
4562: * @method static void setHumanDiffOptions($humanDiffOptions)
4563: * @method static void setTestNow($testNow = null)
4564: * @method static void setUtf8($utf8)
4565: * @method static \Illuminate\Support\Carbon today($tz = null)
4566: * @method static \Illuminate\Support\Carbon tomorrow($tz = null)
4567: * @method static void useStrictMode($strictModeEnabled = true)
4568: * @method static \Illuminate\Support\Carbon yesterday($tz = null)
4569: * @method static \Illuminate\Support\Carbon|false createFromFormat($format, $time, $tz = null)
4570: * @method static \Illuminate\Support\Carbon|false createSafe($year = null, $month = null, $day = null, $hour = null, $minute = null, $second = null, $tz = null)
4571: * @method static \Illuminate\Support\Carbon|null make($var)
4572: * @method static \Symfony\Component\Translation\TranslatorInterface getTranslator()
4573: * @method static array getAvailableLocales()
4574: * @method static array getDays()
4575: * @method static array getIsoUnits()
4576: * @method static array getWeekendDays()
4577: * @method static bool hasFormat($date, $format)
4578: * @method static bool hasMacro($name)
4579: * @method static bool hasRelativeKeywords($time)
4580: * @method static bool hasTestNow()
4581: * @method static bool isImmutable()
4582: * @method static bool isModifiableUnit($unit)
4583: * @method static bool isStrictModeEnabled()
4584: * @method static bool localeHasDiffOneDayWords($locale)
4585: * @method static bool localeHasDiffSyntax($locale)
4586: * @method static bool localeHasDiffTwoDayWords($locale)
4587: * @method static bool localeHasPeriodSyntax($locale)
4588: * @method static bool localeHasShortUnits($locale)
4589: * @method static bool setLocale($locale)
4590: * @method static bool shouldOverflowMonths()
4591: * @method static bool shouldOverflowYears()
4592: * @method static int getHumanDiffOptions()
4593: * @method static int getMidDayAt()
4594: * @method static int getWeekEndsAt()
4595: * @method static int getWeekStartsAt()
4596: * @method static mixed executeWithLocale($locale, $func)
4597: * @method static string getLocale()
4598: * @method static string pluralUnit(string $unit)
4599: * @method static string singularUnit(string $unit)
4600: * @method static void macro($name, $macro)
4601: * @method static void mixin($mixin)
4602: * @method static void resetMonthsOverflow()
4603: * @method static void resetToStringFormat()
4604: * @method static void resetYearsOverflow()
4605: * @method static void serializeUsing($callback)
4606: * @method static void setMidDayAt($hour)
4607: * @method static void setToStringFormat($format)
4608: * @method static void setTranslator(\Symfony\Component\Translation\TranslatorInterface $translator)
4609: * @method static void setWeekEndsAt($day)
4610: * @method static void setWeekStartsAt($day)
4611: * @method static void setWeekendDays($days)
4612: * @method static void useMonthsOverflow($monthsOverflow = true)
4613: * @method static void useYearsOverflow($yearsOverflow = true)
4614: */
4615: class Date {
4616: /**
4617: * Use the given handler when generating dates (class name, callable, or factory).
4618: *
4619: * @param mixed $handler
4620: * @return mixed
4621: * @throws \InvalidArgumentException
4622: * @static
4623: */
4624: public static function use($handler)
4625: {
4626: return \Illuminate\Support\DateFactory::use($handler);
4627: }
4628: /**
4629: * Use the default date class when generating dates.
4630: *
4631: * @return void
4632: * @static
4633: */
4634: public static function useDefault()
4635: {
4636: \Illuminate\Support\DateFactory::useDefault();
4637: }
4638: /**
4639: * Execute the given callable on each date creation.
4640: *
4641: * @param callable $callable
4642: * @return void
4643: * @static
4644: */
4645: public static function useCallable($callable)
4646: {
4647: \Illuminate\Support\DateFactory::useCallable($callable);
4648: }
4649: /**
4650: * Use the given date type (class) when generating dates.
4651: *
4652: * @param string $dateClass
4653: * @return void
4654: * @static
4655: */
4656: public static function useClass($dateClass)
4657: {
4658: \Illuminate\Support\DateFactory::useClass($dateClass);
4659: }
4660: /**
4661: * Use the given Carbon factory when generating dates.
4662: *
4663: * @param object $factory
4664: * @return void
4665: * @static
4666: */
4667: public static function useFactory($factory)
4668: {
4669: \Illuminate\Support\DateFactory::useFactory($factory);
4670: }
4671:
4672: }
4673: /**
4674: *
4675: *
4676: * @see \Illuminate\Database\DatabaseManager
4677: * @see \Illuminate\Database\Connection
4678: */
4679: class DB {
4680: /**
4681: * Get a database connection instance.
4682: *
4683: * @param string|null $name
4684: * @return \Illuminate\Database\Connection
4685: * @static
4686: */
4687: public static function connection($name = null)
4688: {
4689: /** @var \Illuminate\Database\DatabaseManager $instance */
4690: return $instance->connection($name);
4691: }
4692: /**
4693: * Register a custom Doctrine type.
4694: *
4695: * @param string $class
4696: * @param string $name
4697: * @param string $type
4698: * @return void
4699: * @throws \Doctrine\DBAL\DBALException
4700: * @throws \RuntimeException
4701: * @static
4702: */
4703: public static function registerDoctrineType($class, $name, $type)
4704: {
4705: /** @var \Illuminate\Database\DatabaseManager $instance */
4706: $instance->registerDoctrineType($class, $name, $type);
4707: }
4708: /**
4709: * Disconnect from the given database and remove from local cache.
4710: *
4711: * @param string|null $name
4712: * @return void
4713: * @static
4714: */
4715: public static function purge($name = null)
4716: {
4717: /** @var \Illuminate\Database\DatabaseManager $instance */
4718: $instance->purge($name);
4719: }
4720: /**
4721: * Disconnect from the given database.
4722: *
4723: * @param string|null $name
4724: * @return void
4725: * @static
4726: */
4727: public static function disconnect($name = null)
4728: {
4729: /** @var \Illuminate\Database\DatabaseManager $instance */
4730: $instance->disconnect($name);
4731: }
4732: /**
4733: * Reconnect to the given database.
4734: *
4735: * @param string|null $name
4736: * @return \Illuminate\Database\Connection
4737: * @static
4738: */
4739: public static function reconnect($name = null)
4740: {
4741: /** @var \Illuminate\Database\DatabaseManager $instance */
4742: return $instance->reconnect($name);
4743: }
4744: /**
4745: * Set the default database connection for the callback execution.
4746: *
4747: * @param string $name
4748: * @param callable $callback
4749: * @return mixed
4750: * @static
4751: */
4752: public static function usingConnection($name, $callback)
4753: {
4754: /** @var \Illuminate\Database\DatabaseManager $instance */
4755: return $instance->usingConnection($name, $callback);
4756: }
4757: /**
4758: * Get the default connection name.
4759: *
4760: * @return string
4761: * @static
4762: */
4763: public static function getDefaultConnection()
4764: {
4765: /** @var \Illuminate\Database\DatabaseManager $instance */
4766: return $instance->getDefaultConnection();
4767: }
4768: /**
4769: * Set the default connection name.
4770: *
4771: * @param string $name
4772: * @return void
4773: * @static
4774: */
4775: public static function setDefaultConnection($name)
4776: {
4777: /** @var \Illuminate\Database\DatabaseManager $instance */
4778: $instance->setDefaultConnection($name);
4779: }
4780: /**
4781: * Get all of the support drivers.
4782: *
4783: * @return string[]
4784: * @static
4785: */
4786: public static function supportedDrivers()
4787: {
4788: /** @var \Illuminate\Database\DatabaseManager $instance */
4789: return $instance->supportedDrivers();
4790: }
4791: /**
4792: * Get all of the drivers that are actually available.
4793: *
4794: * @return string[]
4795: * @static
4796: */
4797: public static function availableDrivers()
4798: {
4799: /** @var \Illuminate\Database\DatabaseManager $instance */
4800: return $instance->availableDrivers();
4801: }
4802: /**
4803: * Register an extension connection resolver.
4804: *
4805: * @param string $name
4806: * @param callable $resolver
4807: * @return void
4808: * @static
4809: */
4810: public static function extend($name, $resolver)
4811: {
4812: /** @var \Illuminate\Database\DatabaseManager $instance */
4813: $instance->extend($name, $resolver);
4814: }
4815: /**
4816: * Remove an extension connection resolver.
4817: *
4818: * @param string $name
4819: * @return void
4820: * @static
4821: */
4822: public static function forgetExtension($name)
4823: {
4824: /** @var \Illuminate\Database\DatabaseManager $instance */
4825: $instance->forgetExtension($name);
4826: }
4827: /**
4828: * Return all of the created connections.
4829: *
4830: * @return \Illuminate\Database\array<string, \Illuminate\Database\Connection>
4831: * @static
4832: */
4833: public static function getConnections()
4834: {
4835: /** @var \Illuminate\Database\DatabaseManager $instance */
4836: return $instance->getConnections();
4837: }
4838: /**
4839: * Set the database reconnector callback.
4840: *
4841: * @param callable $reconnector
4842: * @return void
4843: * @static
4844: */
4845: public static function setReconnector($reconnector)
4846: {
4847: /** @var \Illuminate\Database\DatabaseManager $instance */
4848: $instance->setReconnector($reconnector);
4849: }
4850: /**
4851: * Set the application instance used by the manager.
4852: *
4853: * @param \Illuminate\Contracts\Foundation\Application $app
4854: * @return \Illuminate\Database\DatabaseManager
4855: * @static
4856: */
4857: public static function setApplication($app)
4858: {
4859: /** @var \Illuminate\Database\DatabaseManager $instance */
4860: return $instance->setApplication($app);
4861: }
4862: /**
4863: * Register a custom macro.
4864: *
4865: * @param string $name
4866: * @param object|callable $macro
4867: * @return void
4868: * @static
4869: */
4870: public static function macro($name, $macro)
4871: {
4872: \Illuminate\Database\DatabaseManager::macro($name, $macro);
4873: }
4874: /**
4875: * Mix another object into the class.
4876: *
4877: * @param object $mixin
4878: * @param bool $replace
4879: * @return void
4880: * @throws \ReflectionException
4881: * @static
4882: */
4883: public static function mixin($mixin, $replace = true)
4884: {
4885: \Illuminate\Database\DatabaseManager::mixin($mixin, $replace);
4886: }
4887: /**
4888: * Checks if macro is registered.
4889: *
4890: * @param string $name
4891: * @return bool
4892: * @static
4893: */
4894: public static function hasMacro($name)
4895: {
4896: return \Illuminate\Database\DatabaseManager::hasMacro($name);
4897: }
4898: /**
4899: * Flush the existing macros.
4900: *
4901: * @return void
4902: * @static
4903: */
4904: public static function flushMacros()
4905: {
4906: \Illuminate\Database\DatabaseManager::flushMacros();
4907: }
4908: /**
4909: * Dynamically handle calls to the class.
4910: *
4911: * @param string $method
4912: * @param array $parameters
4913: * @return mixed
4914: * @throws \BadMethodCallException
4915: * @static
4916: */
4917: public static function macroCall($method, $parameters)
4918: {
4919: /** @var \Illuminate\Database\DatabaseManager $instance */
4920: return $instance->macroCall($method, $parameters);
4921: }
4922: /**
4923: * Determine if the connected database is a MariaDB database.
4924: *
4925: * @return bool
4926: * @static
4927: */
4928: public static function isMaria()
4929: {
4930: /** @var \Illuminate\Database\MySqlConnection $instance */
4931: return $instance->isMaria();
4932: }
4933: /**
4934: * Get a schema builder instance for the connection.
4935: *
4936: * @return \Illuminate\Database\Schema\MySqlBuilder
4937: * @static
4938: */
4939: public static function getSchemaBuilder()
4940: {
4941: /** @var \Illuminate\Database\MySqlConnection $instance */
4942: return $instance->getSchemaBuilder();
4943: }
4944: /**
4945: * Get the schema state for the connection.
4946: *
4947: * @param \Illuminate\Filesystem\Filesystem|null $files
4948: * @param callable|null $processFactory
4949: * @return \Illuminate\Database\Schema\MySqlSchemaState
4950: * @static
4951: */
4952: public static function getSchemaState($files = null, $processFactory = null)
4953: {
4954: /** @var \Illuminate\Database\MySqlConnection $instance */
4955: return $instance->getSchemaState($files, $processFactory);
4956: }
4957: /**
4958: * Set the query grammar to the default implementation.
4959: *
4960: * @return void
4961: * @static
4962: */
4963: public static function useDefaultQueryGrammar()
4964: { //Method inherited from \Illuminate\Database\Connection
4965: /** @var \Illuminate\Database\MySqlConnection $instance */
4966: $instance->useDefaultQueryGrammar();
4967: }
4968: /**
4969: * Set the schema grammar to the default implementation.
4970: *
4971: * @return void
4972: * @static
4973: */
4974: public static function useDefaultSchemaGrammar()
4975: { //Method inherited from \Illuminate\Database\Connection
4976: /** @var \Illuminate\Database\MySqlConnection $instance */
4977: $instance->useDefaultSchemaGrammar();
4978: }
4979: /**
4980: * Set the query post processor to the default implementation.
4981: *
4982: * @return void
4983: * @static
4984: */
4985: public static function useDefaultPostProcessor()
4986: { //Method inherited from \Illuminate\Database\Connection
4987: /** @var \Illuminate\Database\MySqlConnection $instance */
4988: $instance->useDefaultPostProcessor();
4989: }
4990: /**
4991: * Begin a fluent query against a database table.
4992: *
4993: * @param \Closure|\Illuminate\Database\Query\Builder|string $table
4994: * @param string|null $as
4995: * @return \Illuminate\Database\Query\Builder
4996: * @static
4997: */
4998: public static function table($table, $as = null)
4999: { //Method inherited from \Illuminate\Database\Connection
5000: /** @var \Illuminate\Database\MySqlConnection $instance */
5001: return $instance->table($table, $as);
5002: }
5003: /**
5004: * Get a new query builder instance.
5005: *
5006: * @return \Illuminate\Database\Query\Builder
5007: * @static
5008: */
5009: public static function query()
5010: { //Method inherited from \Illuminate\Database\Connection
5011: /** @var \Illuminate\Database\MySqlConnection $instance */
5012: return $instance->query();
5013: }
5014: /**
5015: * Run a select statement and return a single result.
5016: *
5017: * @param string $query
5018: * @param array $bindings
5019: * @param bool $useReadPdo
5020: * @return mixed
5021: * @static
5022: */
5023: public static function selectOne($query, $bindings = [], $useReadPdo = true)
5024: { //Method inherited from \Illuminate\Database\Connection
5025: /** @var \Illuminate\Database\MySqlConnection $instance */
5026: return $instance->selectOne($query, $bindings, $useReadPdo);
5027: }
5028: /**
5029: * Run a select statement and return the first column of the first row.
5030: *
5031: * @param string $query
5032: * @param array $bindings
5033: * @param bool $useReadPdo
5034: * @return mixed
5035: * @throws \Illuminate\Database\MultipleColumnsSelectedException
5036: * @static
5037: */
5038: public static function scalar($query, $bindings = [], $useReadPdo = true)
5039: { //Method inherited from \Illuminate\Database\Connection
5040: /** @var \Illuminate\Database\MySqlConnection $instance */
5041: return $instance->scalar($query, $bindings, $useReadPdo);
5042: }
5043: /**
5044: * Run a select statement against the database.
5045: *
5046: * @param string $query
5047: * @param array $bindings
5048: * @return array
5049: * @static
5050: */
5051: public static function selectFromWriteConnection($query, $bindings = [])
5052: { //Method inherited from \Illuminate\Database\Connection
5053: /** @var \Illuminate\Database\MySqlConnection $instance */
5054: return $instance->selectFromWriteConnection($query, $bindings);
5055: }
5056: /**
5057: * Run a select statement against the database.
5058: *
5059: * @param string $query
5060: * @param array $bindings
5061: * @param bool $useReadPdo
5062: * @return array
5063: * @static
5064: */
5065: public static function select($query, $bindings = [], $useReadPdo = true)
5066: { //Method inherited from \Illuminate\Database\Connection
5067: /** @var \Illuminate\Database\MySqlConnection $instance */
5068: return $instance->select($query, $bindings, $useReadPdo);
5069: }
5070: /**
5071: * Run a select statement against the database and returns a generator.
5072: *
5073: * @param string $query
5074: * @param array $bindings
5075: * @param bool $useReadPdo
5076: * @return \Generator
5077: * @static
5078: */
5079: public static function cursor($query, $bindings = [], $useReadPdo = true)
5080: { //Method inherited from \Illuminate\Database\Connection
5081: /** @var \Illuminate\Database\MySqlConnection $instance */
5082: return $instance->cursor($query, $bindings, $useReadPdo);
5083: }
5084: /**
5085: * Run an insert statement against the database.
5086: *
5087: * @param string $query
5088: * @param array $bindings
5089: * @return bool
5090: * @static
5091: */
5092: public static function insert($query, $bindings = [])
5093: { //Method inherited from \Illuminate\Database\Connection
5094: /** @var \Illuminate\Database\MySqlConnection $instance */
5095: return $instance->insert($query, $bindings);
5096: }
5097: /**
5098: * Run an update statement against the database.
5099: *
5100: * @param string $query
5101: * @param array $bindings
5102: * @return int
5103: * @static
5104: */
5105: public static function update($query, $bindings = [])
5106: { //Method inherited from \Illuminate\Database\Connection
5107: /** @var \Illuminate\Database\MySqlConnection $instance */
5108: return $instance->update($query, $bindings);
5109: }
5110: /**
5111: * Run a delete statement against the database.
5112: *
5113: * @param string $query
5114: * @param array $bindings
5115: * @return int
5116: * @static
5117: */
5118: public static function delete($query, $bindings = [])
5119: { //Method inherited from \Illuminate\Database\Connection
5120: /** @var \Illuminate\Database\MySqlConnection $instance */
5121: return $instance->delete($query, $bindings);
5122: }
5123: /**
5124: * Execute an SQL statement and return the boolean result.
5125: *
5126: * @param string $query
5127: * @param array $bindings
5128: * @return bool
5129: * @static
5130: */
5131: public static function statement($query, $bindings = [])
5132: { //Method inherited from \Illuminate\Database\Connection
5133: /** @var \Illuminate\Database\MySqlConnection $instance */
5134: return $instance->statement($query, $bindings);
5135: }
5136: /**
5137: * Run an SQL statement and get the number of rows affected.
5138: *
5139: * @param string $query
5140: * @param array $bindings
5141: * @return int
5142: * @static
5143: */
5144: public static function affectingStatement($query, $bindings = [])
5145: { //Method inherited from \Illuminate\Database\Connection
5146: /** @var \Illuminate\Database\MySqlConnection $instance */
5147: return $instance->affectingStatement($query, $bindings);
5148: }
5149: /**
5150: * Run a raw, unprepared query against the PDO connection.
5151: *
5152: * @param string $query
5153: * @return bool
5154: * @static
5155: */
5156: public static function unprepared($query)
5157: { //Method inherited from \Illuminate\Database\Connection
5158: /** @var \Illuminate\Database\MySqlConnection $instance */
5159: return $instance->unprepared($query);
5160: }
5161: /**
5162: * Execute the given callback in "dry run" mode.
5163: *
5164: * @param \Closure $callback
5165: * @return array
5166: * @static
5167: */
5168: public static function pretend($callback)
5169: { //Method inherited from \Illuminate\Database\Connection
5170: /** @var \Illuminate\Database\MySqlConnection $instance */
5171: return $instance->pretend($callback);
5172: }
5173: /**
5174: * Bind values to their parameters in the given statement.
5175: *
5176: * @param \PDOStatement $statement
5177: * @param array $bindings
5178: * @return void
5179: * @static
5180: */
5181: public static function bindValues($statement, $bindings)
5182: { //Method inherited from \Illuminate\Database\Connection
5183: /** @var \Illuminate\Database\MySqlConnection $instance */
5184: $instance->bindValues($statement, $bindings);
5185: }
5186: /**
5187: * Prepare the query bindings for execution.
5188: *
5189: * @param array $bindings
5190: * @return array
5191: * @static
5192: */
5193: public static function prepareBindings($bindings)
5194: { //Method inherited from \Illuminate\Database\Connection
5195: /** @var \Illuminate\Database\MySqlConnection $instance */
5196: return $instance->prepareBindings($bindings);
5197: }
5198: /**
5199: * Log a query in the connection's query log.
5200: *
5201: * @param string $query
5202: * @param array $bindings
5203: * @param float|null $time
5204: * @return void
5205: * @static
5206: */
5207: public static function logQuery($query, $bindings, $time = null)
5208: { //Method inherited from \Illuminate\Database\Connection
5209: /** @var \Illuminate\Database\MySqlConnection $instance */
5210: $instance->logQuery($query, $bindings, $time);
5211: }
5212: /**
5213: * Register a callback to be invoked when the connection queries for longer than a given amount of time.
5214: *
5215: * @param \DateTimeInterface|\Carbon\CarbonInterval|float|int $threshold
5216: * @param callable $handler
5217: * @return void
5218: * @static
5219: */
5220: public static function whenQueryingForLongerThan($threshold, $handler)
5221: { //Method inherited from \Illuminate\Database\Connection
5222: /** @var \Illuminate\Database\MySqlConnection $instance */
5223: $instance->whenQueryingForLongerThan($threshold, $handler);
5224: }
5225: /**
5226: * Allow all the query duration handlers to run again, even if they have already run.
5227: *
5228: * @return void
5229: * @static
5230: */
5231: public static function allowQueryDurationHandlersToRunAgain()
5232: { //Method inherited from \Illuminate\Database\Connection
5233: /** @var \Illuminate\Database\MySqlConnection $instance */
5234: $instance->allowQueryDurationHandlersToRunAgain();
5235: }
5236: /**
5237: * Get the duration of all run queries in milliseconds.
5238: *
5239: * @return float
5240: * @static
5241: */
5242: public static function totalQueryDuration()
5243: { //Method inherited from \Illuminate\Database\Connection
5244: /** @var \Illuminate\Database\MySqlConnection $instance */
5245: return $instance->totalQueryDuration();
5246: }
5247: /**
5248: * Reset the duration of all run queries.
5249: *
5250: * @return void
5251: * @static
5252: */
5253: public static function resetTotalQueryDuration()
5254: { //Method inherited from \Illuminate\Database\Connection
5255: /** @var \Illuminate\Database\MySqlConnection $instance */
5256: $instance->resetTotalQueryDuration();
5257: }
5258: /**
5259: * Register a hook to be run just before a database query is executed.
5260: *
5261: * @param \Closure $callback
5262: * @return \Illuminate\Database\MySqlConnection
5263: * @static
5264: */
5265: public static function beforeExecuting($callback)
5266: { //Method inherited from \Illuminate\Database\Connection
5267: /** @var \Illuminate\Database\MySqlConnection $instance */
5268: return $instance->beforeExecuting($callback);
5269: }
5270: /**
5271: * Register a database query listener with the connection.
5272: *
5273: * @param \Closure $callback
5274: * @return void
5275: * @static
5276: */
5277: public static function listen($callback)
5278: { //Method inherited from \Illuminate\Database\Connection
5279: /** @var \Illuminate\Database\MySqlConnection $instance */
5280: $instance->listen($callback);
5281: }
5282: /**
5283: * Get a new raw query expression.
5284: *
5285: * @param mixed $value
5286: * @return \Illuminate\Database\Query\Expression
5287: * @static
5288: */
5289: public static function raw($value)
5290: { //Method inherited from \Illuminate\Database\Connection
5291: /** @var \Illuminate\Database\MySqlConnection $instance */
5292: return $instance->raw($value);
5293: }
5294: /**
5295: * Determine if the database connection has modified any database records.
5296: *
5297: * @return bool
5298: * @static
5299: */
5300: public static function hasModifiedRecords()
5301: { //Method inherited from \Illuminate\Database\Connection
5302: /** @var \Illuminate\Database\MySqlConnection $instance */
5303: return $instance->hasModifiedRecords();
5304: }
5305: /**
5306: * Indicate if any records have been modified.
5307: *
5308: * @param bool $value
5309: * @return void
5310: * @static
5311: */
5312: public static function recordsHaveBeenModified($value = true)
5313: { //Method inherited from \Illuminate\Database\Connection
5314: /** @var \Illuminate\Database\MySqlConnection $instance */
5315: $instance->recordsHaveBeenModified($value);
5316: }
5317: /**
5318: * Set the record modification state.
5319: *
5320: * @param bool $value
5321: * @return \Illuminate\Database\MySqlConnection
5322: * @static
5323: */
5324: public static function setRecordModificationState($value)
5325: { //Method inherited from \Illuminate\Database\Connection
5326: /** @var \Illuminate\Database\MySqlConnection $instance */
5327: return $instance->setRecordModificationState($value);
5328: }
5329: /**
5330: * Reset the record modification state.
5331: *
5332: * @return void
5333: * @static
5334: */
5335: public static function forgetRecordModificationState()
5336: { //Method inherited from \Illuminate\Database\Connection
5337: /** @var \Illuminate\Database\MySqlConnection $instance */
5338: $instance->forgetRecordModificationState();
5339: }
5340: /**
5341: * Indicate that the connection should use the write PDO connection for reads.
5342: *
5343: * @param bool $value
5344: * @return \Illuminate\Database\MySqlConnection
5345: * @static
5346: */
5347: public static function useWriteConnectionWhenReading($value = true)
5348: { //Method inherited from \Illuminate\Database\Connection
5349: /** @var \Illuminate\Database\MySqlConnection $instance */
5350: return $instance->useWriteConnectionWhenReading($value);
5351: }
5352: /**
5353: * Is Doctrine available?
5354: *
5355: * @return bool
5356: * @static
5357: */
5358: public static function isDoctrineAvailable()
5359: { //Method inherited from \Illuminate\Database\Connection
5360: /** @var \Illuminate\Database\MySqlConnection $instance */
5361: return $instance->isDoctrineAvailable();
5362: }
5363: /**
5364: * Get a Doctrine Schema Column instance.
5365: *
5366: * @param string $table
5367: * @param string $column
5368: * @return \Doctrine\DBAL\Schema\Column
5369: * @static
5370: */
5371: public static function getDoctrineColumn($table, $column)
5372: { //Method inherited from \Illuminate\Database\Connection
5373: /** @var \Illuminate\Database\MySqlConnection $instance */
5374: return $instance->getDoctrineColumn($table, $column);
5375: }
5376: /**
5377: * Get the Doctrine DBAL schema manager for the connection.
5378: *
5379: * @return \Doctrine\DBAL\Schema\AbstractSchemaManager
5380: * @static
5381: */
5382: public static function getDoctrineSchemaManager()
5383: { //Method inherited from \Illuminate\Database\Connection
5384: /** @var \Illuminate\Database\MySqlConnection $instance */
5385: return $instance->getDoctrineSchemaManager();
5386: }
5387: /**
5388: * Get the Doctrine DBAL database connection instance.
5389: *
5390: * @return \Doctrine\DBAL\Connection
5391: * @static
5392: */
5393: public static function getDoctrineConnection()
5394: { //Method inherited from \Illuminate\Database\Connection
5395: /** @var \Illuminate\Database\MySqlConnection $instance */
5396: return $instance->getDoctrineConnection();
5397: }
5398: /**
5399: * Get the current PDO connection.
5400: *
5401: * @return \PDO
5402: * @static
5403: */
5404: public static function getPdo()
5405: { //Method inherited from \Illuminate\Database\Connection
5406: /** @var \Illuminate\Database\MySqlConnection $instance */
5407: return $instance->getPdo();
5408: }
5409: /**
5410: * Get the current PDO connection parameter without executing any reconnect logic.
5411: *
5412: * @return \PDO|\Closure|null
5413: * @static
5414: */
5415: public static function getRawPdo()
5416: { //Method inherited from \Illuminate\Database\Connection
5417: /** @var \Illuminate\Database\MySqlConnection $instance */
5418: return $instance->getRawPdo();
5419: }
5420: /**
5421: * Get the current PDO connection used for reading.
5422: *
5423: * @return \PDO
5424: * @static
5425: */
5426: public static function getReadPdo()
5427: { //Method inherited from \Illuminate\Database\Connection
5428: /** @var \Illuminate\Database\MySqlConnection $instance */
5429: return $instance->getReadPdo();
5430: }
5431: /**
5432: * Get the current read PDO connection parameter without executing any reconnect logic.
5433: *
5434: * @return \PDO|\Closure|null
5435: * @static
5436: */
5437: public static function getRawReadPdo()
5438: { //Method inherited from \Illuminate\Database\Connection
5439: /** @var \Illuminate\Database\MySqlConnection $instance */
5440: return $instance->getRawReadPdo();
5441: }
5442: /**
5443: * Set the PDO connection.
5444: *
5445: * @param \PDO|\Closure|null $pdo
5446: * @return \Illuminate\Database\MySqlConnection
5447: * @static
5448: */
5449: public static function setPdo($pdo)
5450: { //Method inherited from \Illuminate\Database\Connection
5451: /** @var \Illuminate\Database\MySqlConnection $instance */
5452: return $instance->setPdo($pdo);
5453: }
5454: /**
5455: * Set the PDO connection used for reading.
5456: *
5457: * @param \PDO|\Closure|null $pdo
5458: * @return \Illuminate\Database\MySqlConnection
5459: * @static
5460: */
5461: public static function setReadPdo($pdo)
5462: { //Method inherited from \Illuminate\Database\Connection
5463: /** @var \Illuminate\Database\MySqlConnection $instance */
5464: return $instance->setReadPdo($pdo);
5465: }
5466: /**
5467: * Get the database connection name.
5468: *
5469: * @return string|null
5470: * @static
5471: */
5472: public static function getName()
5473: { //Method inherited from \Illuminate\Database\Connection
5474: /** @var \Illuminate\Database\MySqlConnection $instance */
5475: return $instance->getName();
5476: }
5477: /**
5478: * Get the database connection full name.
5479: *
5480: * @return string|null
5481: * @static
5482: */
5483: public static function getNameWithReadWriteType()
5484: { //Method inherited from \Illuminate\Database\Connection
5485: /** @var \Illuminate\Database\MySqlConnection $instance */
5486: return $instance->getNameWithReadWriteType();
5487: }
5488: /**
5489: * Get an option from the configuration options.
5490: *
5491: * @param string|null $option
5492: * @return mixed
5493: * @static
5494: */
5495: public static function getConfig($option = null)
5496: { //Method inherited from \Illuminate\Database\Connection
5497: /** @var \Illuminate\Database\MySqlConnection $instance */
5498: return $instance->getConfig($option);
5499: }
5500: /**
5501: * Get the PDO driver name.
5502: *
5503: * @return string
5504: * @static
5505: */
5506: public static function getDriverName()
5507: { //Method inherited from \Illuminate\Database\Connection
5508: /** @var \Illuminate\Database\MySqlConnection $instance */
5509: return $instance->getDriverName();
5510: }
5511: /**
5512: * Get the query grammar used by the connection.
5513: *
5514: * @return \Illuminate\Database\Query\Grammars\Grammar
5515: * @static
5516: */
5517: public static function getQueryGrammar()
5518: { //Method inherited from \Illuminate\Database\Connection
5519: /** @var \Illuminate\Database\MySqlConnection $instance */
5520: return $instance->getQueryGrammar();
5521: }
5522: /**
5523: * Set the query grammar used by the connection.
5524: *
5525: * @param \Illuminate\Database\Query\Grammars\Grammar $grammar
5526: * @return \Illuminate\Database\MySqlConnection
5527: * @static
5528: */
5529: public static function setQueryGrammar($grammar)
5530: { //Method inherited from \Illuminate\Database\Connection
5531: /** @var \Illuminate\Database\MySqlConnection $instance */
5532: return $instance->setQueryGrammar($grammar);
5533: }
5534: /**
5535: * Get the schema grammar used by the connection.
5536: *
5537: * @return \Illuminate\Database\Schema\Grammars\Grammar
5538: * @static
5539: */
5540: public static function getSchemaGrammar()
5541: { //Method inherited from \Illuminate\Database\Connection
5542: /** @var \Illuminate\Database\MySqlConnection $instance */
5543: return $instance->getSchemaGrammar();
5544: }
5545: /**
5546: * Set the schema grammar used by the connection.
5547: *
5548: * @param \Illuminate\Database\Schema\Grammars\Grammar $grammar
5549: * @return \Illuminate\Database\MySqlConnection
5550: * @static
5551: */
5552: public static function setSchemaGrammar($grammar)
5553: { //Method inherited from \Illuminate\Database\Connection
5554: /** @var \Illuminate\Database\MySqlConnection $instance */
5555: return $instance->setSchemaGrammar($grammar);
5556: }
5557: /**
5558: * Get the query post processor used by the connection.
5559: *
5560: * @return \Illuminate\Database\Query\Processors\Processor
5561: * @static
5562: */
5563: public static function getPostProcessor()
5564: { //Method inherited from \Illuminate\Database\Connection
5565: /** @var \Illuminate\Database\MySqlConnection $instance */
5566: return $instance->getPostProcessor();
5567: }
5568: /**
5569: * Set the query post processor used by the connection.
5570: *
5571: * @param \Illuminate\Database\Query\Processors\Processor $processor
5572: * @return \Illuminate\Database\MySqlConnection
5573: * @static
5574: */
5575: public static function setPostProcessor($processor)
5576: { //Method inherited from \Illuminate\Database\Connection
5577: /** @var \Illuminate\Database\MySqlConnection $instance */
5578: return $instance->setPostProcessor($processor);
5579: }
5580: /**
5581: * Get the event dispatcher used by the connection.
5582: *
5583: * @return \Illuminate\Contracts\Events\Dispatcher
5584: * @static
5585: */
5586: public static function getEventDispatcher()
5587: { //Method inherited from \Illuminate\Database\Connection
5588: /** @var \Illuminate\Database\MySqlConnection $instance */
5589: return $instance->getEventDispatcher();
5590: }
5591: /**
5592: * Set the event dispatcher instance on the connection.
5593: *
5594: * @param \Illuminate\Contracts\Events\Dispatcher $events
5595: * @return \Illuminate\Database\MySqlConnection
5596: * @static
5597: */
5598: public static function setEventDispatcher($events)
5599: { //Method inherited from \Illuminate\Database\Connection
5600: /** @var \Illuminate\Database\MySqlConnection $instance */
5601: return $instance->setEventDispatcher($events);
5602: }
5603: /**
5604: * Unset the event dispatcher for this connection.
5605: *
5606: * @return void
5607: * @static
5608: */
5609: public static function unsetEventDispatcher()
5610: { //Method inherited from \Illuminate\Database\Connection
5611: /** @var \Illuminate\Database\MySqlConnection $instance */
5612: $instance->unsetEventDispatcher();
5613: }
5614: /**
5615: * Set the transaction manager instance on the connection.
5616: *
5617: * @param \Illuminate\Database\DatabaseTransactionsManager $manager
5618: * @return \Illuminate\Database\MySqlConnection
5619: * @static
5620: */
5621: public static function setTransactionManager($manager)
5622: { //Method inherited from \Illuminate\Database\Connection
5623: /** @var \Illuminate\Database\MySqlConnection $instance */
5624: return $instance->setTransactionManager($manager);
5625: }
5626: /**
5627: * Unset the transaction manager for this connection.
5628: *
5629: * @return void
5630: * @static
5631: */
5632: public static function unsetTransactionManager()
5633: { //Method inherited from \Illuminate\Database\Connection
5634: /** @var \Illuminate\Database\MySqlConnection $instance */
5635: $instance->unsetTransactionManager();
5636: }
5637: /**
5638: * Determine if the connection is in a "dry run".
5639: *
5640: * @return bool
5641: * @static
5642: */
5643: public static function pretending()
5644: { //Method inherited from \Illuminate\Database\Connection
5645: /** @var \Illuminate\Database\MySqlConnection $instance */
5646: return $instance->pretending();
5647: }
5648: /**
5649: * Get the connection query log.
5650: *
5651: * @return array
5652: * @static
5653: */
5654: public static function getQueryLog()
5655: { //Method inherited from \Illuminate\Database\Connection
5656: /** @var \Illuminate\Database\MySqlConnection $instance */
5657: return $instance->getQueryLog();
5658: }
5659: /**
5660: * Clear the query log.
5661: *
5662: * @return void
5663: * @static
5664: */
5665: public static function flushQueryLog()
5666: { //Method inherited from \Illuminate\Database\Connection
5667: /** @var \Illuminate\Database\MySqlConnection $instance */
5668: $instance->flushQueryLog();
5669: }
5670: /**
5671: * Enable the query log on the connection.
5672: *
5673: * @return void
5674: * @static
5675: */
5676: public static function enableQueryLog()
5677: { //Method inherited from \Illuminate\Database\Connection
5678: /** @var \Illuminate\Database\MySqlConnection $instance */
5679: $instance->enableQueryLog();
5680: }
5681: /**
5682: * Disable the query log on the connection.
5683: *
5684: * @return void
5685: * @static
5686: */
5687: public static function disableQueryLog()
5688: { //Method inherited from \Illuminate\Database\Connection
5689: /** @var \Illuminate\Database\MySqlConnection $instance */
5690: $instance->disableQueryLog();
5691: }
5692: /**
5693: * Determine whether we're logging queries.
5694: *
5695: * @return bool
5696: * @static
5697: */
5698: public static function logging()
5699: { //Method inherited from \Illuminate\Database\Connection
5700: /** @var \Illuminate\Database\MySqlConnection $instance */
5701: return $instance->logging();
5702: }
5703: /**
5704: * Get the name of the connected database.
5705: *
5706: * @return string
5707: * @static
5708: */
5709: public static function getDatabaseName()
5710: { //Method inherited from \Illuminate\Database\Connection
5711: /** @var \Illuminate\Database\MySqlConnection $instance */
5712: return $instance->getDatabaseName();
5713: }
5714: /**
5715: * Set the name of the connected database.
5716: *
5717: * @param string $database
5718: * @return \Illuminate\Database\MySqlConnection
5719: * @static
5720: */
5721: public static function setDatabaseName($database)
5722: { //Method inherited from \Illuminate\Database\Connection
5723: /** @var \Illuminate\Database\MySqlConnection $instance */
5724: return $instance->setDatabaseName($database);
5725: }
5726: /**
5727: * Set the read / write type of the connection.
5728: *
5729: * @param string|null $readWriteType
5730: * @return \Illuminate\Database\MySqlConnection
5731: * @static
5732: */
5733: public static function setReadWriteType($readWriteType)
5734: { //Method inherited from \Illuminate\Database\Connection
5735: /** @var \Illuminate\Database\MySqlConnection $instance */
5736: return $instance->setReadWriteType($readWriteType);
5737: }
5738: /**
5739: * Get the table prefix for the connection.
5740: *
5741: * @return string
5742: * @static
5743: */
5744: public static function getTablePrefix()
5745: { //Method inherited from \Illuminate\Database\Connection
5746: /** @var \Illuminate\Database\MySqlConnection $instance */
5747: return $instance->getTablePrefix();
5748: }
5749: /**
5750: * Set the table prefix in use by the connection.
5751: *
5752: * @param string $prefix
5753: * @return \Illuminate\Database\MySqlConnection
5754: * @static
5755: */
5756: public static function setTablePrefix($prefix)
5757: { //Method inherited from \Illuminate\Database\Connection
5758: /** @var \Illuminate\Database\MySqlConnection $instance */
5759: return $instance->setTablePrefix($prefix);
5760: }
5761: /**
5762: * Set the table prefix and return the grammar.
5763: *
5764: * @param \Illuminate\Database\Grammar $grammar
5765: * @return \Illuminate\Database\Grammar
5766: * @static
5767: */
5768: public static function withTablePrefix($grammar)
5769: { //Method inherited from \Illuminate\Database\Connection
5770: /** @var \Illuminate\Database\MySqlConnection $instance */
5771: return $instance->withTablePrefix($grammar);
5772: }
5773: /**
5774: * Register a connection resolver.
5775: *
5776: * @param string $driver
5777: * @param \Closure $callback
5778: * @return void
5779: * @static
5780: */
5781: public static function resolverFor($driver, $callback)
5782: { //Method inherited from \Illuminate\Database\Connection
5783: \Illuminate\Database\MySqlConnection::resolverFor($driver, $callback);
5784: }
5785: /**
5786: * Get the connection resolver for the given driver.
5787: *
5788: * @param string $driver
5789: * @return mixed
5790: * @static
5791: */
5792: public static function getResolver($driver)
5793: { //Method inherited from \Illuminate\Database\Connection
5794: return \Illuminate\Database\MySqlConnection::getResolver($driver);
5795: }
5796: /**
5797: * Execute a Closure within a transaction.
5798: *
5799: * @param \Closure $callback
5800: * @param int $attempts
5801: * @return mixed
5802: * @throws \Throwable
5803: * @static
5804: */
5805: public static function transaction($callback, $attempts = 1)
5806: { //Method inherited from \Illuminate\Database\Connection
5807: /** @var \Illuminate\Database\MySqlConnection $instance */
5808: return $instance->transaction($callback, $attempts);
5809: }
5810: /**
5811: * Start a new database transaction.
5812: *
5813: * @return void
5814: * @throws \Throwable
5815: * @static
5816: */
5817: public static function beginTransaction()
5818: { //Method inherited from \Illuminate\Database\Connection
5819: /** @var \Illuminate\Database\MySqlConnection $instance */
5820: $instance->beginTransaction();
5821: }
5822: /**
5823: * Commit the active database transaction.
5824: *
5825: * @return void
5826: * @throws \Throwable
5827: * @static
5828: */
5829: public static function commit()
5830: { //Method inherited from \Illuminate\Database\Connection
5831: /** @var \Illuminate\Database\MySqlConnection $instance */
5832: $instance->commit();
5833: }
5834: /**
5835: * Rollback the active database transaction.
5836: *
5837: * @param int|null $toLevel
5838: * @return void
5839: * @throws \Throwable
5840: * @static
5841: */
5842: public static function rollBack($toLevel = null)
5843: { //Method inherited from \Illuminate\Database\Connection
5844: /** @var \Illuminate\Database\MySqlConnection $instance */
5845: $instance->rollBack($toLevel);
5846: }
5847: /**
5848: * Get the number of active transactions.
5849: *
5850: * @return int
5851: * @static
5852: */
5853: public static function transactionLevel()
5854: { //Method inherited from \Illuminate\Database\Connection
5855: /** @var \Illuminate\Database\MySqlConnection $instance */
5856: return $instance->transactionLevel();
5857: }
5858: /**
5859: * Execute the callback after a transaction commits.
5860: *
5861: * @param callable $callback
5862: * @return void
5863: * @throws \RuntimeException
5864: * @static
5865: */
5866: public static function afterCommit($callback)
5867: { //Method inherited from \Illuminate\Database\Connection
5868: /** @var \Illuminate\Database\MySqlConnection $instance */
5869: $instance->afterCommit($callback);
5870: }
5871:
5872: }
5873: /**
5874: *
5875: *
5876: * @see \Illuminate\Events\Dispatcher
5877: */
5878: class Event {
5879: /**
5880: * Register an event listener with the dispatcher.
5881: *
5882: * @param \Closure|string|array $events
5883: * @param \Closure|string|array|null $listener
5884: * @return void
5885: * @static
5886: */
5887: public static function listen($events, $listener = null)
5888: {
5889: /** @var \Illuminate\Events\Dispatcher $instance */
5890: $instance->listen($events, $listener);
5891: }
5892: /**
5893: * Determine if a given event has listeners.
5894: *
5895: * @param string $eventName
5896: * @return bool
5897: * @static
5898: */
5899: public static function hasListeners($eventName)
5900: {
5901: /** @var \Illuminate\Events\Dispatcher $instance */
5902: return $instance->hasListeners($eventName);
5903: }
5904: /**
5905: * Determine if the given event has any wildcard listeners.
5906: *
5907: * @param string $eventName
5908: * @return bool
5909: * @static
5910: */
5911: public static function hasWildcardListeners($eventName)
5912: {
5913: /** @var \Illuminate\Events\Dispatcher $instance */
5914: return $instance->hasWildcardListeners($eventName);
5915: }
5916: /**
5917: * Register an event and payload to be fired later.
5918: *
5919: * @param string $event
5920: * @param object|array $payload
5921: * @return void
5922: * @static
5923: */
5924: public static function push($event, $payload = [])
5925: {
5926: /** @var \Illuminate\Events\Dispatcher $instance */
5927: $instance->push($event, $payload);
5928: }
5929: /**
5930: * Flush a set of pushed events.
5931: *
5932: * @param string $event
5933: * @return void
5934: * @static
5935: */
5936: public static function flush($event)
5937: {
5938: /** @var \Illuminate\Events\Dispatcher $instance */
5939: $instance->flush($event);
5940: }
5941: /**
5942: * Register an event subscriber with the dispatcher.
5943: *
5944: * @param object|string $subscriber
5945: * @return void
5946: * @static
5947: */
5948: public static function subscribe($subscriber)
5949: {
5950: /** @var \Illuminate\Events\Dispatcher $instance */
5951: $instance->subscribe($subscriber);
5952: }
5953: /**
5954: * Fire an event until the first non-null response is returned.
5955: *
5956: * @param string|object $event
5957: * @param mixed $payload
5958: * @return array|null
5959: * @static
5960: */
5961: public static function until($event, $payload = [])
5962: {
5963: /** @var \Illuminate\Events\Dispatcher $instance */
5964: return $instance->until($event, $payload);
5965: }
5966: /**
5967: * Fire an event and call the listeners.
5968: *
5969: * @param string|object $event
5970: * @param mixed $payload
5971: * @param bool $halt
5972: * @return array|null
5973: * @static
5974: */
5975: public static function dispatch($event, $payload = [], $halt = false)
5976: {
5977: /** @var \Illuminate\Events\Dispatcher $instance */
5978: return $instance->dispatch($event, $payload, $halt);
5979: }
5980: /**
5981: * Get all of the listeners for a given event name.
5982: *
5983: * @param string $eventName
5984: * @return array
5985: * @static
5986: */
5987: public static function getListeners($eventName)
5988: {
5989: /** @var \Illuminate\Events\Dispatcher $instance */
5990: return $instance->getListeners($eventName);
5991: }
5992: /**
5993: * Register an event listener with the dispatcher.
5994: *
5995: * @param \Closure|string|array $listener
5996: * @param bool $wildcard
5997: * @return \Closure
5998: * @static
5999: */
6000: public static function makeListener($listener, $wildcard = false)
6001: {
6002: /** @var \Illuminate\Events\Dispatcher $instance */
6003: return $instance->makeListener($listener, $wildcard);
6004: }
6005: /**
6006: * Create a class based listener using the IoC container.
6007: *
6008: * @param string $listener
6009: * @param bool $wildcard
6010: * @return \Closure
6011: * @static
6012: */
6013: public static function createClassListener($listener, $wildcard = false)
6014: {
6015: /** @var \Illuminate\Events\Dispatcher $instance */
6016: return $instance->createClassListener($listener, $wildcard);
6017: }
6018: /**
6019: * Remove a set of listeners from the dispatcher.
6020: *
6021: * @param string $event
6022: * @return void
6023: * @static
6024: */
6025: public static function forget($event)
6026: {
6027: /** @var \Illuminate\Events\Dispatcher $instance */
6028: $instance->forget($event);
6029: }
6030: /**
6031: * Forget all of the pushed listeners.
6032: *
6033: * @return void
6034: * @static
6035: */
6036: public static function forgetPushed()
6037: {
6038: /** @var \Illuminate\Events\Dispatcher $instance */
6039: $instance->forgetPushed();
6040: }
6041: /**
6042: * Set the queue resolver implementation.
6043: *
6044: * @param callable $resolver
6045: * @return \Illuminate\Events\Dispatcher
6046: * @static
6047: */
6048: public static function setQueueResolver($resolver)
6049: {
6050: /** @var \Illuminate\Events\Dispatcher $instance */
6051: return $instance->setQueueResolver($resolver);
6052: }
6053: /**
6054: * Gets the raw, unprepared listeners.
6055: *
6056: * @return array
6057: * @static
6058: */
6059: public static function getRawListeners()
6060: {
6061: /** @var \Illuminate\Events\Dispatcher $instance */
6062: return $instance->getRawListeners();
6063: }
6064: /**
6065: * Register a custom macro.
6066: *
6067: * @param string $name
6068: * @param object|callable $macro
6069: * @return void
6070: * @static
6071: */
6072: public static function macro($name, $macro)
6073: {
6074: \Illuminate\Events\Dispatcher::macro($name, $macro);
6075: }
6076: /**
6077: * Mix another object into the class.
6078: *
6079: * @param object $mixin
6080: * @param bool $replace
6081: * @return void
6082: * @throws \ReflectionException
6083: * @static
6084: */
6085: public static function mixin($mixin, $replace = true)
6086: {
6087: \Illuminate\Events\Dispatcher::mixin($mixin, $replace);
6088: }
6089: /**
6090: * Checks if macro is registered.
6091: *
6092: * @param string $name
6093: * @return bool
6094: * @static
6095: */
6096: public static function hasMacro($name)
6097: {
6098: return \Illuminate\Events\Dispatcher::hasMacro($name);
6099: }
6100: /**
6101: * Flush the existing macros.
6102: *
6103: * @return void
6104: * @static
6105: */
6106: public static function flushMacros()
6107: {
6108: \Illuminate\Events\Dispatcher::flushMacros();
6109: }
6110: /**
6111: * Assert if an event has a listener attached to it.
6112: *
6113: * @param string $expectedEvent
6114: * @param string|array $expectedListener
6115: * @return void
6116: * @static
6117: */
6118: public static function assertListening($expectedEvent, $expectedListener)
6119: {
6120: /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6121: $instance->assertListening($expectedEvent, $expectedListener);
6122: }
6123: /**
6124: * Assert if an event was dispatched based on a truth-test callback.
6125: *
6126: * @param string|\Closure $event
6127: * @param callable|int|null $callback
6128: * @return void
6129: * @static
6130: */
6131: public static function assertDispatched($event, $callback = null)
6132: {
6133: /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6134: $instance->assertDispatched($event, $callback);
6135: }
6136: /**
6137: * Assert if an event was dispatched a number of times.
6138: *
6139: * @param string $event
6140: * @param int $times
6141: * @return void
6142: * @static
6143: */
6144: public static function assertDispatchedTimes($event, $times = 1)
6145: {
6146: /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6147: $instance->assertDispatchedTimes($event, $times);
6148: }
6149: /**
6150: * Determine if an event was dispatched based on a truth-test callback.
6151: *
6152: * @param string|\Closure $event
6153: * @param callable|null $callback
6154: * @return void
6155: * @static
6156: */
6157: public static function assertNotDispatched($event, $callback = null)
6158: {
6159: /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6160: $instance->assertNotDispatched($event, $callback);
6161: }
6162: /**
6163: * Assert that no events were dispatched.
6164: *
6165: * @return void
6166: * @static
6167: */
6168: public static function assertNothingDispatched()
6169: {
6170: /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6171: $instance->assertNothingDispatched();
6172: }
6173: /**
6174: * Get all of the events matching a truth-test callback.
6175: *
6176: * @param string $event
6177: * @param callable|null $callback
6178: * @return \Illuminate\Support\Collection
6179: * @static
6180: */
6181: public static function dispatched($event, $callback = null)
6182: {
6183: /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6184: return $instance->dispatched($event, $callback);
6185: }
6186: /**
6187: * Determine if the given event has been dispatched.
6188: *
6189: * @param string $event
6190: * @return bool
6191: * @static
6192: */
6193: public static function hasDispatched($event)
6194: {
6195: /** @var \Illuminate\Support\Testing\Fakes\EventFake $instance */
6196: return $instance->hasDispatched($event);
6197: }
6198:
6199: }
6200: /**
6201: *
6202: *
6203: * @see \Illuminate\Filesystem\Filesystem
6204: */
6205: class File {
6206: /**
6207: * Determine if a file or directory exists.
6208: *
6209: * @param string $path
6210: * @return bool
6211: * @static
6212: */
6213: public static function exists($path)
6214: {
6215: /** @var \Illuminate\Filesystem\Filesystem $instance */
6216: return $instance->exists($path);
6217: }
6218: /**
6219: * Determine if a file or directory is missing.
6220: *
6221: * @param string $path
6222: * @return bool
6223: * @static
6224: */
6225: public static function missing($path)
6226: {
6227: /** @var \Illuminate\Filesystem\Filesystem $instance */
6228: return $instance->missing($path);
6229: }
6230: /**
6231: * Get the contents of a file.
6232: *
6233: * @param string $path
6234: * @param bool $lock
6235: * @return string
6236: * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6237: * @static
6238: */
6239: public static function get($path, $lock = false)
6240: {
6241: /** @var \Illuminate\Filesystem\Filesystem $instance */
6242: return $instance->get($path, $lock);
6243: }
6244: /**
6245: * Get contents of a file with shared access.
6246: *
6247: * @param string $path
6248: * @return string
6249: * @static
6250: */
6251: public static function sharedGet($path)
6252: {
6253: /** @var \Illuminate\Filesystem\Filesystem $instance */
6254: return $instance->sharedGet($path);
6255: }
6256: /**
6257: * Get the returned value of a file.
6258: *
6259: * @param string $path
6260: * @param array $data
6261: * @return mixed
6262: * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6263: * @static
6264: */
6265: public static function getRequire($path, $data = [])
6266: {
6267: /** @var \Illuminate\Filesystem\Filesystem $instance */
6268: return $instance->getRequire($path, $data);
6269: }
6270: /**
6271: * Require the given file once.
6272: *
6273: * @param string $path
6274: * @param array $data
6275: * @return mixed
6276: * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6277: * @static
6278: */
6279: public static function requireOnce($path, $data = [])
6280: {
6281: /** @var \Illuminate\Filesystem\Filesystem $instance */
6282: return $instance->requireOnce($path, $data);
6283: }
6284: /**
6285: * Get the contents of a file one line at a time.
6286: *
6287: * @param string $path
6288: * @return \Illuminate\Support\LazyCollection
6289: * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
6290: * @static
6291: */
6292: public static function lines($path)
6293: {
6294: /** @var \Illuminate\Filesystem\Filesystem $instance */
6295: return $instance->lines($path);
6296: }
6297: /**
6298: * Get the MD5 hash of the file at the given path.
6299: *
6300: * @param string $path
6301: * @return string
6302: * @static
6303: */
6304: public static function hash($path)
6305: {
6306: /** @var \Illuminate\Filesystem\Filesystem $instance */
6307: return $instance->hash($path);
6308: }
6309: /**
6310: * Write the contents of a file.
6311: *
6312: * @param string $path
6313: * @param string $contents
6314: * @param bool $lock
6315: * @return int|bool
6316: * @static
6317: */
6318: public static function put($path, $contents, $lock = false)
6319: {
6320: /** @var \Illuminate\Filesystem\Filesystem $instance */
6321: return $instance->put($path, $contents, $lock);
6322: }
6323: /**
6324: * Write the contents of a file, replacing it atomically if it already exists.
6325: *
6326: * @param string $path
6327: * @param string $content
6328: * @return void
6329: * @static
6330: */
6331: public static function replace($path, $content)
6332: {
6333: /** @var \Illuminate\Filesystem\Filesystem $instance */
6334: $instance->replace($path, $content);
6335: }
6336: /**
6337: * Replace a given string within a given file.
6338: *
6339: * @param array|string $search
6340: * @param array|string $replace
6341: * @param string $path
6342: * @return void
6343: * @static
6344: */
6345: public static function replaceInFile($search, $replace, $path)
6346: {
6347: /** @var \Illuminate\Filesystem\Filesystem $instance */
6348: $instance->replaceInFile($search, $replace, $path);
6349: }
6350: /**
6351: * Prepend to a file.
6352: *
6353: * @param string $path
6354: * @param string $data
6355: * @return int
6356: * @static
6357: */
6358: public static function prepend($path, $data)
6359: {
6360: /** @var \Illuminate\Filesystem\Filesystem $instance */
6361: return $instance->prepend($path, $data);
6362: }
6363: /**
6364: * Append to a file.
6365: *
6366: * @param string $path
6367: * @param string $data
6368: * @return int
6369: * @static
6370: */
6371: public static function append($path, $data)
6372: {
6373: /** @var \Illuminate\Filesystem\Filesystem $instance */
6374: return $instance->append($path, $data);
6375: }
6376: /**
6377: * Get or set UNIX mode of a file or directory.
6378: *
6379: * @param string $path
6380: * @param int|null $mode
6381: * @return mixed
6382: * @static
6383: */
6384: public static function chmod($path, $mode = null)
6385: {
6386: /** @var \Illuminate\Filesystem\Filesystem $instance */
6387: return $instance->chmod($path, $mode);
6388: }
6389: /**
6390: * Delete the file at a given path.
6391: *
6392: * @param string|array $paths
6393: * @return bool
6394: * @static
6395: */
6396: public static function delete($paths)
6397: {
6398: /** @var \Illuminate\Filesystem\Filesystem $instance */
6399: return $instance->delete($paths);
6400: }
6401: /**
6402: * Move a file to a new location.
6403: *
6404: * @param string $path
6405: * @param string $target
6406: * @return bool
6407: * @static
6408: */
6409: public static function move($path, $target)
6410: {
6411: /** @var \Illuminate\Filesystem\Filesystem $instance */
6412: return $instance->move($path, $target);
6413: }
6414: /**
6415: * Copy a file to a new location.
6416: *
6417: * @param string $path
6418: * @param string $target
6419: * @return bool
6420: * @static
6421: */
6422: public static function copy($path, $target)
6423: {
6424: /** @var \Illuminate\Filesystem\Filesystem $instance */
6425: return $instance->copy($path, $target);
6426: }
6427: /**
6428: * Create a symlink to the target file or directory. On Windows, a hard link is created if the target is a file.
6429: *
6430: * @param string $target
6431: * @param string $link
6432: * @return void
6433: * @static
6434: */
6435: public static function link($target, $link)
6436: {
6437: /** @var \Illuminate\Filesystem\Filesystem $instance */
6438: $instance->link($target, $link);
6439: }
6440: /**
6441: * Create a relative symlink to the target file or directory.
6442: *
6443: * @param string $target
6444: * @param string $link
6445: * @return void
6446: * @throws \RuntimeException
6447: * @static
6448: */
6449: public static function relativeLink($target, $link)
6450: {
6451: /** @var \Illuminate\Filesystem\Filesystem $instance */
6452: $instance->relativeLink($target, $link);
6453: }
6454: /**
6455: * Extract the file name from a file path.
6456: *
6457: * @param string $path
6458: * @return string
6459: * @static
6460: */
6461: public static function name($path)
6462: {
6463: /** @var \Illuminate\Filesystem\Filesystem $instance */
6464: return $instance->name($path);
6465: }
6466: /**
6467: * Extract the trailing name component from a file path.
6468: *
6469: * @param string $path
6470: * @return string
6471: * @static
6472: */
6473: public static function basename($path)
6474: {
6475: /** @var \Illuminate\Filesystem\Filesystem $instance */
6476: return $instance->basename($path);
6477: }
6478: /**
6479: * Extract the parent directory from a file path.
6480: *
6481: * @param string $path
6482: * @return string
6483: * @static
6484: */
6485: public static function dirname($path)
6486: {
6487: /** @var \Illuminate\Filesystem\Filesystem $instance */
6488: return $instance->dirname($path);
6489: }
6490: /**
6491: * Extract the file extension from a file path.
6492: *
6493: * @param string $path
6494: * @return string
6495: * @static
6496: */
6497: public static function extension($path)
6498: {
6499: /** @var \Illuminate\Filesystem\Filesystem $instance */
6500: return $instance->extension($path);
6501: }
6502: /**
6503: * Guess the file extension from the mime-type of a given file.
6504: *
6505: * @param string $path
6506: * @return string|null
6507: * @throws \RuntimeException
6508: * @static
6509: */
6510: public static function guessExtension($path)
6511: {
6512: /** @var \Illuminate\Filesystem\Filesystem $instance */
6513: return $instance->guessExtension($path);
6514: }
6515: /**
6516: * Get the file type of a given file.
6517: *
6518: * @param string $path
6519: * @return string
6520: * @static
6521: */
6522: public static function type($path)
6523: {
6524: /** @var \Illuminate\Filesystem\Filesystem $instance */
6525: return $instance->type($path);
6526: }
6527: /**
6528: * Get the mime-type of a given file.
6529: *
6530: * @param string $path
6531: * @return string|false
6532: * @static
6533: */
6534: public static function mimeType($path)
6535: {
6536: /** @var \Illuminate\Filesystem\Filesystem $instance */
6537: return $instance->mimeType($path);
6538: }
6539: /**
6540: * Get the file size of a given file.
6541: *
6542: * @param string $path
6543: * @return int
6544: * @static
6545: */
6546: public static function size($path)
6547: {
6548: /** @var \Illuminate\Filesystem\Filesystem $instance */
6549: return $instance->size($path);
6550: }
6551: /**
6552: * Get the file's last modification time.
6553: *
6554: * @param string $path
6555: * @return int
6556: * @static
6557: */
6558: public static function lastModified($path)
6559: {
6560: /** @var \Illuminate\Filesystem\Filesystem $instance */
6561: return $instance->lastModified($path);
6562: }
6563: /**
6564: * Determine if the given path is a directory.
6565: *
6566: * @param string $directory
6567: * @return bool
6568: * @static
6569: */
6570: public static function isDirectory($directory)
6571: {
6572: /** @var \Illuminate\Filesystem\Filesystem $instance */
6573: return $instance->isDirectory($directory);
6574: }
6575: /**
6576: * Determine if the given path is a directory that does not contain any other files or directories.
6577: *
6578: * @param string $directory
6579: * @param bool $ignoreDotFiles
6580: * @return bool
6581: * @static
6582: */
6583: public static function isEmptyDirectory($directory, $ignoreDotFiles = false)
6584: {
6585: /** @var \Illuminate\Filesystem\Filesystem $instance */
6586: return $instance->isEmptyDirectory($directory, $ignoreDotFiles);
6587: }
6588: /**
6589: * Determine if the given path is readable.
6590: *
6591: * @param string $path
6592: * @return bool
6593: * @static
6594: */
6595: public static function isReadable($path)
6596: {
6597: /** @var \Illuminate\Filesystem\Filesystem $instance */
6598: return $instance->isReadable($path);
6599: }
6600: /**
6601: * Determine if the given path is writable.
6602: *
6603: * @param string $path
6604: * @return bool
6605: * @static
6606: */
6607: public static function isWritable($path)
6608: {
6609: /** @var \Illuminate\Filesystem\Filesystem $instance */
6610: return $instance->isWritable($path);
6611: }
6612: /**
6613: * Determine if two files are the same by comparing their hashes.
6614: *
6615: * @param string $firstFile
6616: * @param string $secondFile
6617: * @return bool
6618: * @static
6619: */
6620: public static function hasSameHash($firstFile, $secondFile)
6621: {
6622: /** @var \Illuminate\Filesystem\Filesystem $instance */
6623: return $instance->hasSameHash($firstFile, $secondFile);
6624: }
6625: /**
6626: * Determine if the given path is a file.
6627: *
6628: * @param string $file
6629: * @return bool
6630: * @static
6631: */
6632: public static function isFile($file)
6633: {
6634: /** @var \Illuminate\Filesystem\Filesystem $instance */
6635: return $instance->isFile($file);
6636: }
6637: /**
6638: * Find path names matching a given pattern.
6639: *
6640: * @param string $pattern
6641: * @param int $flags
6642: * @return array
6643: * @static
6644: */
6645: public static function glob($pattern, $flags = 0)
6646: {
6647: /** @var \Illuminate\Filesystem\Filesystem $instance */
6648: return $instance->glob($pattern, $flags);
6649: }
6650: /**
6651: * Get an array of all files in a directory.
6652: *
6653: * @param string $directory
6654: * @param bool $hidden
6655: * @return \Symfony\Component\Finder\SplFileInfo[]
6656: * @static
6657: */
6658: public static function files($directory, $hidden = false)
6659: {
6660: /** @var \Illuminate\Filesystem\Filesystem $instance */
6661: return $instance->files($directory, $hidden);
6662: }
6663: /**
6664: * Get all of the files from the given directory (recursive).
6665: *
6666: * @param string $directory
6667: * @param bool $hidden
6668: * @return \Symfony\Component\Finder\SplFileInfo[]
6669: * @static
6670: */
6671: public static function allFiles($directory, $hidden = false)
6672: {
6673: /** @var \Illuminate\Filesystem\Filesystem $instance */
6674: return $instance->allFiles($directory, $hidden);
6675: }
6676: /**
6677: * Get all of the directories within a given directory.
6678: *
6679: * @param string $directory
6680: * @return array
6681: * @static
6682: */
6683: public static function directories($directory)
6684: {
6685: /** @var \Illuminate\Filesystem\Filesystem $instance */
6686: return $instance->directories($directory);
6687: }
6688: /**
6689: * Ensure a directory exists.
6690: *
6691: * @param string $path
6692: * @param int $mode
6693: * @param bool $recursive
6694: * @return void
6695: * @static
6696: */
6697: public static function ensureDirectoryExists($path, $mode = 493, $recursive = true)
6698: {
6699: /** @var \Illuminate\Filesystem\Filesystem $instance */
6700: $instance->ensureDirectoryExists($path, $mode, $recursive);
6701: }
6702: /**
6703: * Create a directory.
6704: *
6705: * @param string $path
6706: * @param int $mode
6707: * @param bool $recursive
6708: * @param bool $force
6709: * @return bool
6710: * @static
6711: */
6712: public static function makeDirectory($path, $mode = 493, $recursive = false, $force = false)
6713: {
6714: /** @var \Illuminate\Filesystem\Filesystem $instance */
6715: return $instance->makeDirectory($path, $mode, $recursive, $force);
6716: }
6717: /**
6718: * Move a directory.
6719: *
6720: * @param string $from
6721: * @param string $to
6722: * @param bool $overwrite
6723: * @return bool
6724: * @static
6725: */
6726: public static function moveDirectory($from, $to, $overwrite = false)
6727: {
6728: /** @var \Illuminate\Filesystem\Filesystem $instance */
6729: return $instance->moveDirectory($from, $to, $overwrite);
6730: }
6731: /**
6732: * Copy a directory from one location to another.
6733: *
6734: * @param string $directory
6735: * @param string $destination
6736: * @param int|null $options
6737: * @return bool
6738: * @static
6739: */
6740: public static function copyDirectory($directory, $destination, $options = null)
6741: {
6742: /** @var \Illuminate\Filesystem\Filesystem $instance */
6743: return $instance->copyDirectory($directory, $destination, $options);
6744: }
6745: /**
6746: * Recursively delete a directory.
6747: *
6748: * The directory itself may be optionally preserved.
6749: *
6750: * @param string $directory
6751: * @param bool $preserve
6752: * @return bool
6753: * @static
6754: */
6755: public static function deleteDirectory($directory, $preserve = false)
6756: {
6757: /** @var \Illuminate\Filesystem\Filesystem $instance */
6758: return $instance->deleteDirectory($directory, $preserve);
6759: }
6760: /**
6761: * Remove all of the directories within a given directory.
6762: *
6763: * @param string $directory
6764: * @return bool
6765: * @static
6766: */
6767: public static function deleteDirectories($directory)
6768: {
6769: /** @var \Illuminate\Filesystem\Filesystem $instance */
6770: return $instance->deleteDirectories($directory);
6771: }
6772: /**
6773: * Empty the specified directory of all files and folders.
6774: *
6775: * @param string $directory
6776: * @return bool
6777: * @static
6778: */
6779: public static function cleanDirectory($directory)
6780: {
6781: /** @var \Illuminate\Filesystem\Filesystem $instance */
6782: return $instance->cleanDirectory($directory);
6783: }
6784: /**
6785: * Register a custom macro.
6786: *
6787: * @param string $name
6788: * @param object|callable $macro
6789: * @return void
6790: * @static
6791: */
6792: public static function macro($name, $macro)
6793: {
6794: \Illuminate\Filesystem\Filesystem::macro($name, $macro);
6795: }
6796: /**
6797: * Mix another object into the class.
6798: *
6799: * @param object $mixin
6800: * @param bool $replace
6801: * @return void
6802: * @throws \ReflectionException
6803: * @static
6804: */
6805: public static function mixin($mixin, $replace = true)
6806: {
6807: \Illuminate\Filesystem\Filesystem::mixin($mixin, $replace);
6808: }
6809: /**
6810: * Checks if macro is registered.
6811: *
6812: * @param string $name
6813: * @return bool
6814: * @static
6815: */
6816: public static function hasMacro($name)
6817: {
6818: return \Illuminate\Filesystem\Filesystem::hasMacro($name);
6819: }
6820: /**
6821: * Flush the existing macros.
6822: *
6823: * @return void
6824: * @static
6825: */
6826: public static function flushMacros()
6827: {
6828: \Illuminate\Filesystem\Filesystem::flushMacros();
6829: }
6830: /**
6831: *
6832: *
6833: * @see \Blueprint\FileMixins::stub()
6834: * @param mixed $path
6835: * @static
6836: */
6837: public static function stub($path)
6838: {
6839: return \Illuminate\Filesystem\Filesystem::stub($path);
6840: }
6841:
6842: }
6843: /**
6844: *
6845: *
6846: * @see \Illuminate\Contracts\Auth\Access\Gate
6847: */
6848: class Gate {
6849: /**
6850: * Determine if a given ability has been defined.
6851: *
6852: * @param string|array $ability
6853: * @return bool
6854: * @static
6855: */
6856: public static function has($ability)
6857: {
6858: /** @var \Illuminate\Auth\Access\Gate $instance */
6859: return $instance->has($ability);
6860: }
6861: /**
6862: * Perform an on-demand authorization check. Throw an authorization exception if the condition or callback is false.
6863: *
6864: * @param \Illuminate\Auth\Access\Response|\Closure|bool $condition
6865: * @param string|null $message
6866: * @param string|null $code
6867: * @return \Illuminate\Auth\Access\Response
6868: * @throws \Illuminate\Auth\Access\AuthorizationException
6869: * @static
6870: */
6871: public static function allowIf($condition, $message = null, $code = null)
6872: {
6873: /** @var \Illuminate\Auth\Access\Gate $instance */
6874: return $instance->allowIf($condition, $message, $code);
6875: }
6876: /**
6877: * Perform an on-demand authorization check. Throw an authorization exception if the condition or callback is true.
6878: *
6879: * @param \Illuminate\Auth\Access\Response|\Closure|bool $condition
6880: * @param string|null $message
6881: * @param string|null $code
6882: * @return \Illuminate\Auth\Access\Response
6883: * @throws \Illuminate\Auth\Access\AuthorizationException
6884: * @static
6885: */
6886: public static function denyIf($condition, $message = null, $code = null)
6887: {
6888: /** @var \Illuminate\Auth\Access\Gate $instance */
6889: return $instance->denyIf($condition, $message, $code);
6890: }
6891: /**
6892: * Define a new ability.
6893: *
6894: * @param string $ability
6895: * @param callable|array|string $callback
6896: * @return \Illuminate\Auth\Access\Gate
6897: * @throws \InvalidArgumentException
6898: * @static
6899: */
6900: public static function define($ability, $callback)
6901: {
6902: /** @var \Illuminate\Auth\Access\Gate $instance */
6903: return $instance->define($ability, $callback);
6904: }
6905: /**
6906: * Define abilities for a resource.
6907: *
6908: * @param string $name
6909: * @param string $class
6910: * @param array|null $abilities
6911: * @return \Illuminate\Auth\Access\Gate
6912: * @static
6913: */
6914: public static function resource($name, $class, $abilities = null)
6915: {
6916: /** @var \Illuminate\Auth\Access\Gate $instance */
6917: return $instance->resource($name, $class, $abilities);
6918: }
6919: /**
6920: * Define a policy class for a given class type.
6921: *
6922: * @param string $class
6923: * @param string $policy
6924: * @return \Illuminate\Auth\Access\Gate
6925: * @static
6926: */
6927: public static function policy($class, $policy)
6928: {
6929: /** @var \Illuminate\Auth\Access\Gate $instance */
6930: return $instance->policy($class, $policy);
6931: }
6932: /**
6933: * Register a callback to run before all Gate checks.
6934: *
6935: * @param callable $callback
6936: * @return \Illuminate\Auth\Access\Gate
6937: * @static
6938: */
6939: public static function before($callback)
6940: {
6941: /** @var \Illuminate\Auth\Access\Gate $instance */
6942: return $instance->before($callback);
6943: }
6944: /**
6945: * Register a callback to run after all Gate checks.
6946: *
6947: * @param callable $callback
6948: * @return \Illuminate\Auth\Access\Gate
6949: * @static
6950: */
6951: public static function after($callback)
6952: {
6953: /** @var \Illuminate\Auth\Access\Gate $instance */
6954: return $instance->after($callback);
6955: }
6956: /**
6957: * Determine if the given ability should be granted for the current user.
6958: *
6959: * @param string $ability
6960: * @param array|mixed $arguments
6961: * @return bool
6962: * @static
6963: */
6964: public static function allows($ability, $arguments = [])
6965: {
6966: /** @var \Illuminate\Auth\Access\Gate $instance */
6967: return $instance->allows($ability, $arguments);
6968: }
6969: /**
6970: * Determine if the given ability should be denied for the current user.
6971: *
6972: * @param string $ability
6973: * @param array|mixed $arguments
6974: * @return bool
6975: * @static
6976: */
6977: public static function denies($ability, $arguments = [])
6978: {
6979: /** @var \Illuminate\Auth\Access\Gate $instance */
6980: return $instance->denies($ability, $arguments);
6981: }
6982: /**
6983: * Determine if all of the given abilities should be granted for the current user.
6984: *
6985: * @param \Illuminate\Auth\Access\iterable|string $abilities
6986: * @param array|mixed $arguments
6987: * @return bool
6988: * @static
6989: */
6990: public static function check($abilities, $arguments = [])
6991: {
6992: /** @var \Illuminate\Auth\Access\Gate $instance */
6993: return $instance->check($abilities, $arguments);
6994: }
6995: /**
6996: * Determine if any one of the given abilities should be granted for the current user.
6997: *
6998: * @param \Illuminate\Auth\Access\iterable|string $abilities
6999: * @param array|mixed $arguments
7000: * @return bool
7001: * @static
7002: */
7003: public static function any($abilities, $arguments = [])
7004: {
7005: /** @var \Illuminate\Auth\Access\Gate $instance */
7006: return $instance->any($abilities, $arguments);
7007: }
7008: /**
7009: * Determine if all of the given abilities should be denied for the current user.
7010: *
7011: * @param \Illuminate\Auth\Access\iterable|string $abilities
7012: * @param array|mixed $arguments
7013: * @return bool
7014: * @static
7015: */
7016: public static function none($abilities, $arguments = [])
7017: {
7018: /** @var \Illuminate\Auth\Access\Gate $instance */
7019: return $instance->none($abilities, $arguments);
7020: }
7021: /**
7022: * Determine if the given ability should be granted for the current user.
7023: *
7024: * @param string $ability
7025: * @param array|mixed $arguments
7026: * @return \Illuminate\Auth\Access\Response
7027: * @throws \Illuminate\Auth\Access\AuthorizationException
7028: * @static
7029: */
7030: public static function authorize($ability, $arguments = [])
7031: {
7032: /** @var \Illuminate\Auth\Access\Gate $instance */
7033: return $instance->authorize($ability, $arguments);
7034: }
7035: /**
7036: * Inspect the user for the given ability.
7037: *
7038: * @param string $ability
7039: * @param array|mixed $arguments
7040: * @return \Illuminate\Auth\Access\Response
7041: * @static
7042: */
7043: public static function inspect($ability, $arguments = [])
7044: {
7045: /** @var \Illuminate\Auth\Access\Gate $instance */
7046: return $instance->inspect($ability, $arguments);
7047: }
7048: /**
7049: * Get the raw result from the authorization callback.
7050: *
7051: * @param string $ability
7052: * @param array|mixed $arguments
7053: * @return mixed
7054: * @throws \Illuminate\Auth\Access\AuthorizationException
7055: * @static
7056: */
7057: public static function raw($ability, $arguments = [])
7058: {
7059: /** @var \Illuminate\Auth\Access\Gate $instance */
7060: return $instance->raw($ability, $arguments);
7061: }
7062: /**
7063: * Get a policy instance for a given class.
7064: *
7065: * @param object|string $class
7066: * @return mixed
7067: * @static
7068: */
7069: public static function getPolicyFor($class)
7070: {
7071: /** @var \Illuminate\Auth\Access\Gate $instance */
7072: return $instance->getPolicyFor($class);
7073: }
7074: /**
7075: * Specify a callback to be used to guess policy names.
7076: *
7077: * @param callable $callback
7078: * @return \Illuminate\Auth\Access\Gate
7079: * @static
7080: */
7081: public static function guessPolicyNamesUsing($callback)
7082: {
7083: /** @var \Illuminate\Auth\Access\Gate $instance */
7084: return $instance->guessPolicyNamesUsing($callback);
7085: }
7086: /**
7087: * Build a policy class instance of the given type.
7088: *
7089: * @param object|string $class
7090: * @return mixed
7091: * @throws \Illuminate\Contracts\Container\BindingResolutionException
7092: * @static
7093: */
7094: public static function resolvePolicy($class)
7095: {
7096: /** @var \Illuminate\Auth\Access\Gate $instance */
7097: return $instance->resolvePolicy($class);
7098: }
7099: /**
7100: * Get a gate instance for the given user.
7101: *
7102: * @param \Illuminate\Contracts\Auth\Authenticatable|mixed $user
7103: * @return static
7104: * @static
7105: */
7106: public static function forUser($user)
7107: {
7108: /** @var \Illuminate\Auth\Access\Gate $instance */
7109: return $instance->forUser($user);
7110: }
7111: /**
7112: * Get all of the defined abilities.
7113: *
7114: * @return array
7115: * @static
7116: */
7117: public static function abilities()
7118: {
7119: /** @var \Illuminate\Auth\Access\Gate $instance */
7120: return $instance->abilities();
7121: }
7122: /**
7123: * Get all of the defined policies.
7124: *
7125: * @return array
7126: * @static
7127: */
7128: public static function policies()
7129: {
7130: /** @var \Illuminate\Auth\Access\Gate $instance */
7131: return $instance->policies();
7132: }
7133: /**
7134: * Set the container instance used by the gate.
7135: *
7136: * @param \Illuminate\Contracts\Container\Container $container
7137: * @return \Illuminate\Auth\Access\Gate
7138: * @static
7139: */
7140: public static function setContainer($container)
7141: {
7142: /** @var \Illuminate\Auth\Access\Gate $instance */
7143: return $instance->setContainer($container);
7144: }
7145: /**
7146: * Deny with a HTTP status code.
7147: *
7148: * @param int $status
7149: * @param \Illuminate\Auth\Access\?string $message
7150: * @param \Illuminate\Auth\Access\?int $code
7151: * @return \Illuminate\Auth\Access\Response
7152: * @static
7153: */
7154: public static function denyWithStatus($status, $message = null, $code = null)
7155: {
7156: /** @var \Illuminate\Auth\Access\Gate $instance */
7157: return $instance->denyWithStatus($status, $message, $code);
7158: }
7159: /**
7160: * Deny with a 404 HTTP status code.
7161: *
7162: * @param \Illuminate\Auth\Access\?string $message
7163: * @param \Illuminate\Auth\Access\?int $code
7164: * @return \Illuminate\Auth\Access\Response
7165: * @static
7166: */
7167: public static function denyAsNotFound($message = null, $code = null)
7168: {
7169: /** @var \Illuminate\Auth\Access\Gate $instance */
7170: return $instance->denyAsNotFound($message, $code);
7171: }
7172:
7173: }
7174: /**
7175: *
7176: *
7177: * @see \Illuminate\Hashing\HashManager
7178: */
7179: class Hash {
7180: /**
7181: * Create an instance of the Bcrypt hash Driver.
7182: *
7183: * @return \Illuminate\Hashing\BcryptHasher
7184: * @static
7185: */
7186: public static function createBcryptDriver()
7187: {
7188: /** @var \Illuminate\Hashing\HashManager $instance */
7189: return $instance->createBcryptDriver();
7190: }
7191: /**
7192: * Create an instance of the Argon2i hash Driver.
7193: *
7194: * @return \Illuminate\Hashing\ArgonHasher
7195: * @static
7196: */
7197: public static function createArgonDriver()
7198: {
7199: /** @var \Illuminate\Hashing\HashManager $instance */
7200: return $instance->createArgonDriver();
7201: }
7202: /**
7203: * Create an instance of the Argon2id hash Driver.
7204: *
7205: * @return \Illuminate\Hashing\Argon2IdHasher
7206: * @static
7207: */
7208: public static function createArgon2idDriver()
7209: {
7210: /** @var \Illuminate\Hashing\HashManager $instance */
7211: return $instance->createArgon2idDriver();
7212: }
7213: /**
7214: * Get information about the given hashed value.
7215: *
7216: * @param string $hashedValue
7217: * @return array
7218: * @static
7219: */
7220: public static function info($hashedValue)
7221: {
7222: /** @var \Illuminate\Hashing\HashManager $instance */
7223: return $instance->info($hashedValue);
7224: }
7225: /**
7226: * Hash the given value.
7227: *
7228: * @param string $value
7229: * @param array $options
7230: * @return string
7231: * @static
7232: */
7233: public static function make($value, $options = [])
7234: {
7235: /** @var \Illuminate\Hashing\HashManager $instance */
7236: return $instance->make($value, $options);
7237: }
7238: /**
7239: * Check the given plain value against a hash.
7240: *
7241: * @param string $value
7242: * @param string $hashedValue
7243: * @param array $options
7244: * @return bool
7245: * @static
7246: */
7247: public static function check($value, $hashedValue, $options = [])
7248: {
7249: /** @var \Illuminate\Hashing\HashManager $instance */
7250: return $instance->check($value, $hashedValue, $options);
7251: }
7252: /**
7253: * Check if the given hash has been hashed using the given options.
7254: *
7255: * @param string $hashedValue
7256: * @param array $options
7257: * @return bool
7258: * @static
7259: */
7260: public static function needsRehash($hashedValue, $options = [])
7261: {
7262: /** @var \Illuminate\Hashing\HashManager $instance */
7263: return $instance->needsRehash($hashedValue, $options);
7264: }
7265: /**
7266: * Get the default driver name.
7267: *
7268: * @return string
7269: * @static
7270: */
7271: public static function getDefaultDriver()
7272: {
7273: /** @var \Illuminate\Hashing\HashManager $instance */
7274: return $instance->getDefaultDriver();
7275: }
7276: /**
7277: * Get a driver instance.
7278: *
7279: * @param string|null $driver
7280: * @return mixed
7281: * @throws \InvalidArgumentException
7282: * @static
7283: */
7284: public static function driver($driver = null)
7285: { //Method inherited from \Illuminate\Support\Manager
7286: /** @var \Illuminate\Hashing\HashManager $instance */
7287: return $instance->driver($driver);
7288: }
7289: /**
7290: * Register a custom driver creator Closure.
7291: *
7292: * @param string $driver
7293: * @param \Closure $callback
7294: * @return \Illuminate\Hashing\HashManager
7295: * @static
7296: */
7297: public static function extend($driver, $callback)
7298: { //Method inherited from \Illuminate\Support\Manager
7299: /** @var \Illuminate\Hashing\HashManager $instance */
7300: return $instance->extend($driver, $callback);
7301: }
7302: /**
7303: * Get all of the created "drivers".
7304: *
7305: * @return array
7306: * @static
7307: */
7308: public static function getDrivers()
7309: { //Method inherited from \Illuminate\Support\Manager
7310: /** @var \Illuminate\Hashing\HashManager $instance */
7311: return $instance->getDrivers();
7312: }
7313: /**
7314: * Get the container instance used by the manager.
7315: *
7316: * @return \Illuminate\Contracts\Container\Container
7317: * @static
7318: */
7319: public static function getContainer()
7320: { //Method inherited from \Illuminate\Support\Manager
7321: /** @var \Illuminate\Hashing\HashManager $instance */
7322: return $instance->getContainer();
7323: }
7324: /**
7325: * Set the container instance used by the manager.
7326: *
7327: * @param \Illuminate\Contracts\Container\Container $container
7328: * @return \Illuminate\Hashing\HashManager
7329: * @static
7330: */
7331: public static function setContainer($container)
7332: { //Method inherited from \Illuminate\Support\Manager
7333: /** @var \Illuminate\Hashing\HashManager $instance */
7334: return $instance->setContainer($container);
7335: }
7336: /**
7337: * Forget all of the resolved driver instances.
7338: *
7339: * @return \Illuminate\Hashing\HashManager
7340: * @static
7341: */
7342: public static function forgetDrivers()
7343: { //Method inherited from \Illuminate\Support\Manager
7344: /** @var \Illuminate\Hashing\HashManager $instance */
7345: return $instance->forgetDrivers();
7346: }
7347:
7348: }
7349: /**
7350: *
7351: *
7352: * @method static \Illuminate\Http\Client\PendingRequest accept(string $contentType)
7353: * @method static \Illuminate\Http\Client\PendingRequest acceptJson()
7354: * @method static \Illuminate\Http\Client\PendingRequest asForm()
7355: * @method static \Illuminate\Http\Client\PendingRequest asJson()
7356: * @method static \Illuminate\Http\Client\PendingRequest asMultipart()
7357: * @method static \Illuminate\Http\Client\PendingRequest async()
7358: * @method static \Illuminate\Http\Client\PendingRequest attach(string|array $name, string $contents = '', string|null $filename = null, array $headers = [])
7359: * @method static \Illuminate\Http\Client\PendingRequest baseUrl(string $url)
7360: * @method static \Illuminate\Http\Client\PendingRequest beforeSending(callable $callback)
7361: * @method static \Illuminate\Http\Client\PendingRequest bodyFormat(string $format)
7362: * @method static \Illuminate\Http\Client\PendingRequest connectTimeout(int $seconds)
7363: * @method static \Illuminate\Http\Client\PendingRequest contentType(string $contentType)
7364: * @method static \Illuminate\Http\Client\PendingRequest dd()
7365: * @method static \Illuminate\Http\Client\PendingRequest dump()
7366: * @method static \Illuminate\Http\Client\PendingRequest maxRedirects(int $max)
7367: * @method static \Illuminate\Http\Client\PendingRequest retry(int $times, int $sleepMilliseconds = 0, ?callable $when = null, bool $throw = true)
7368: * @method static \Illuminate\Http\Client\PendingRequest sink(string|resource $to)
7369: * @method static \Illuminate\Http\Client\PendingRequest stub(callable $callback)
7370: * @method static \Illuminate\Http\Client\PendingRequest timeout(int $seconds)
7371: * @method static \Illuminate\Http\Client\PendingRequest withBasicAuth(string $username, string $password)
7372: * @method static \Illuminate\Http\Client\PendingRequest withBody(resource|string $content, string $contentType)
7373: * @method static \Illuminate\Http\Client\PendingRequest withCookies(array $cookies, string $domain)
7374: * @method static \Illuminate\Http\Client\PendingRequest withDigestAuth(string $username, string $password)
7375: * @method static \Illuminate\Http\Client\PendingRequest withHeaders(array $headers)
7376: * @method static \Illuminate\Http\Client\PendingRequest withMiddleware(callable $middleware)
7377: * @method static \Illuminate\Http\Client\PendingRequest withOptions(array $options)
7378: * @method static \Illuminate\Http\Client\PendingRequest withToken(string $token, string $type = 'Bearer')
7379: * @method static \Illuminate\Http\Client\PendingRequest withUserAgent(string $userAgent)
7380: * @method static \Illuminate\Http\Client\PendingRequest withoutRedirecting()
7381: * @method static \Illuminate\Http\Client\PendingRequest withoutVerifying()
7382: * @method static \Illuminate\Http\Client\PendingRequest throw(callable $callback = null)
7383: * @method static \Illuminate\Http\Client\PendingRequest throwIf($condition)
7384: * @method \Illuminate\Http\Client\PendingRequest throwUnless($condition)
7385: * @method static array pool(callable $callback)
7386: * @method static \Illuminate\Http\Client\Response delete(string $url, array $data = [])
7387: * @method static \Illuminate\Http\Client\Response get(string $url, array|string|null $query = null)
7388: * @method static \Illuminate\Http\Client\Response head(string $url, array|string|null $query = null)
7389: * @method static \Illuminate\Http\Client\Response patch(string $url, array $data = [])
7390: * @method static \Illuminate\Http\Client\Response post(string $url, array $data = [])
7391: * @method static \Illuminate\Http\Client\Response put(string $url, array $data = [])
7392: * @method static \Illuminate\Http\Client\Response send(string $method, string $url, array $options = [])
7393: * @see \Illuminate\Http\Client\Factory
7394: */
7395: class Http {
7396: /**
7397: * Create a new response instance for use during stubbing.
7398: *
7399: * @param array|string|null $body
7400: * @param int $status
7401: * @param array $headers
7402: * @return \GuzzleHttp\Promise\PromiseInterface
7403: * @static
7404: */
7405: public static function response($body = null, $status = 200, $headers = [])
7406: {
7407: return \Illuminate\Http\Client\Factory::response($body, $status, $headers);
7408: }
7409: /**
7410: * Get an invokable object that returns a sequence of responses in order for use during stubbing.
7411: *
7412: * @param array $responses
7413: * @return \Illuminate\Http\Client\ResponseSequence
7414: * @static
7415: */
7416: public static function sequence($responses = [])
7417: {
7418: /** @var \Illuminate\Http\Client\Factory $instance */
7419: return $instance->sequence($responses);
7420: }
7421: /**
7422: * Register a stub callable that will intercept requests and be able to return stub responses.
7423: *
7424: * @param callable|array $callback
7425: * @return \Illuminate\Http\Client\Factory
7426: * @static
7427: */
7428: public static function fake($callback = null)
7429: {
7430: /** @var \Illuminate\Http\Client\Factory $instance */
7431: return $instance->fake($callback);
7432: }
7433: /**
7434: * Register a response sequence for the given URL pattern.
7435: *
7436: * @param string $url
7437: * @return \Illuminate\Http\Client\ResponseSequence
7438: * @static
7439: */
7440: public static function fakeSequence($url = '*')
7441: {
7442: /** @var \Illuminate\Http\Client\Factory $instance */
7443: return $instance->fakeSequence($url);
7444: }
7445: /**
7446: * Stub the given URL using the given callback.
7447: *
7448: * @param string $url
7449: * @param \Illuminate\Http\Client\Response|\GuzzleHttp\Promise\PromiseInterface|callable $callback
7450: * @return \Illuminate\Http\Client\Factory
7451: * @static
7452: */
7453: public static function stubUrl($url, $callback)
7454: {
7455: /** @var \Illuminate\Http\Client\Factory $instance */
7456: return $instance->stubUrl($url, $callback);
7457: }
7458: /**
7459: * Indicate that an exception should be thrown if any request is not faked.
7460: *
7461: * @param bool $prevent
7462: * @return \Illuminate\Http\Client\Factory
7463: * @static
7464: */
7465: public static function preventStrayRequests($prevent = true)
7466: {
7467: /** @var \Illuminate\Http\Client\Factory $instance */
7468: return $instance->preventStrayRequests($prevent);
7469: }
7470: /**
7471: * Indicate that an exception should not be thrown if any request is not faked.
7472: *
7473: * @return \Illuminate\Http\Client\Factory
7474: * @static
7475: */
7476: public static function allowStrayRequests()
7477: {
7478: /** @var \Illuminate\Http\Client\Factory $instance */
7479: return $instance->allowStrayRequests();
7480: }
7481: /**
7482: * Record a request response pair.
7483: *
7484: * @param \Illuminate\Http\Client\Request $request
7485: * @param \Illuminate\Http\Client\Response $response
7486: * @return void
7487: * @static
7488: */
7489: public static function recordRequestResponsePair($request, $response)
7490: {
7491: /** @var \Illuminate\Http\Client\Factory $instance */
7492: $instance->recordRequestResponsePair($request, $response);
7493: }
7494: /**
7495: * Assert that a request / response pair was recorded matching a given truth test.
7496: *
7497: * @param callable $callback
7498: * @return void
7499: * @static
7500: */
7501: public static function assertSent($callback)
7502: {
7503: /** @var \Illuminate\Http\Client\Factory $instance */
7504: $instance->assertSent($callback);
7505: }
7506: /**
7507: * Assert that the given request was sent in the given order.
7508: *
7509: * @param array $callbacks
7510: * @return void
7511: * @static
7512: */
7513: public static function assertSentInOrder($callbacks)
7514: {
7515: /** @var \Illuminate\Http\Client\Factory $instance */
7516: $instance->assertSentInOrder($callbacks);
7517: }
7518: /**
7519: * Assert that a request / response pair was not recorded matching a given truth test.
7520: *
7521: * @param callable $callback
7522: * @return void
7523: * @static
7524: */
7525: public static function assertNotSent($callback)
7526: {
7527: /** @var \Illuminate\Http\Client\Factory $instance */
7528: $instance->assertNotSent($callback);
7529: }
7530: /**
7531: * Assert that no request / response pair was recorded.
7532: *
7533: * @return void
7534: * @static
7535: */
7536: public static function assertNothingSent()
7537: {
7538: /** @var \Illuminate\Http\Client\Factory $instance */
7539: $instance->assertNothingSent();
7540: }
7541: /**
7542: * Assert how many requests have been recorded.
7543: *
7544: * @param int $count
7545: * @return void
7546: * @static
7547: */
7548: public static function assertSentCount($count)
7549: {
7550: /** @var \Illuminate\Http\Client\Factory $instance */
7551: $instance->assertSentCount($count);
7552: }
7553: /**
7554: * Assert that every created response sequence is empty.
7555: *
7556: * @return void
7557: * @static
7558: */
7559: public static function assertSequencesAreEmpty()
7560: {
7561: /** @var \Illuminate\Http\Client\Factory $instance */
7562: $instance->assertSequencesAreEmpty();
7563: }
7564: /**
7565: * Get a collection of the request / response pairs matching the given truth test.
7566: *
7567: * @param callable $callback
7568: * @return \Illuminate\Support\Collection
7569: * @static
7570: */
7571: public static function recorded($callback = null)
7572: {
7573: /** @var \Illuminate\Http\Client\Factory $instance */
7574: return $instance->recorded($callback);
7575: }
7576: /**
7577: * Get the current event dispatcher implementation.
7578: *
7579: * @return \Illuminate\Contracts\Events\Dispatcher|null
7580: * @static
7581: */
7582: public static function getDispatcher()
7583: {
7584: /** @var \Illuminate\Http\Client\Factory $instance */
7585: return $instance->getDispatcher();
7586: }
7587: /**
7588: * Register a custom macro.
7589: *
7590: * @param string $name
7591: * @param object|callable $macro
7592: * @return void
7593: * @static
7594: */
7595: public static function macro($name, $macro)
7596: {
7597: \Illuminate\Http\Client\Factory::macro($name, $macro);
7598: }
7599: /**
7600: * Mix another object into the class.
7601: *
7602: * @param object $mixin
7603: * @param bool $replace
7604: * @return void
7605: * @throws \ReflectionException
7606: * @static
7607: */
7608: public static function mixin($mixin, $replace = true)
7609: {
7610: \Illuminate\Http\Client\Factory::mixin($mixin, $replace);
7611: }
7612: /**
7613: * Checks if macro is registered.
7614: *
7615: * @param string $name
7616: * @return bool
7617: * @static
7618: */
7619: public static function hasMacro($name)
7620: {
7621: return \Illuminate\Http\Client\Factory::hasMacro($name);
7622: }
7623: /**
7624: * Flush the existing macros.
7625: *
7626: * @return void
7627: * @static
7628: */
7629: public static function flushMacros()
7630: {
7631: \Illuminate\Http\Client\Factory::flushMacros();
7632: }
7633: /**
7634: * Dynamically handle calls to the class.
7635: *
7636: * @param string $method
7637: * @param array $parameters
7638: * @return mixed
7639: * @throws \BadMethodCallException
7640: * @static
7641: */
7642: public static function macroCall($method, $parameters)
7643: {
7644: /** @var \Illuminate\Http\Client\Factory $instance */
7645: return $instance->macroCall($method, $parameters);
7646: }
7647:
7648: }
7649: /**
7650: *
7651: *
7652: * @see \Illuminate\Translation\Translator
7653: */
7654: class Lang {
7655: /**
7656: * Determine if a translation exists for a given locale.
7657: *
7658: * @param string $key
7659: * @param string|null $locale
7660: * @return bool
7661: * @static
7662: */
7663: public static function hasForLocale($key, $locale = null)
7664: {
7665: /** @var \Illuminate\Translation\Translator $instance */
7666: return $instance->hasForLocale($key, $locale);
7667: }
7668: /**
7669: * Determine if a translation exists.
7670: *
7671: * @param string $key
7672: * @param string|null $locale
7673: * @param bool $fallback
7674: * @return bool
7675: * @static
7676: */
7677: public static function has($key, $locale = null, $fallback = true)
7678: {
7679: /** @var \Illuminate\Translation\Translator $instance */
7680: return $instance->has($key, $locale, $fallback);
7681: }
7682: /**
7683: * Get the translation for the given key.
7684: *
7685: * @param string $key
7686: * @param array $replace
7687: * @param string|null $locale
7688: * @param bool $fallback
7689: * @return string|array
7690: * @static
7691: */
7692: public static function get($key, $replace = [], $locale = null, $fallback = true)
7693: {
7694: /** @var \Illuminate\Translation\Translator $instance */
7695: return $instance->get($key, $replace, $locale, $fallback);
7696: }
7697: /**
7698: * Get a translation according to an integer value.
7699: *
7700: * @param string $key
7701: * @param \Countable|int|array $number
7702: * @param array $replace
7703: * @param string|null $locale
7704: * @return string
7705: * @static
7706: */
7707: public static function choice($key, $number, $replace = [], $locale = null)
7708: {
7709: /** @var \Illuminate\Translation\Translator $instance */
7710: return $instance->choice($key, $number, $replace, $locale);
7711: }
7712: /**
7713: * Add translation lines to the given locale.
7714: *
7715: * @param array $lines
7716: * @param string $locale
7717: * @param string $namespace
7718: * @return void
7719: * @static
7720: */
7721: public static function addLines($lines, $locale, $namespace = '*')
7722: {
7723: /** @var \Illuminate\Translation\Translator $instance */
7724: $instance->addLines($lines, $locale, $namespace);
7725: }
7726: /**
7727: * Load the specified language group.
7728: *
7729: * @param string $namespace
7730: * @param string $group
7731: * @param string $locale
7732: * @return void
7733: * @static
7734: */
7735: public static function load($namespace, $group, $locale)
7736: {
7737: /** @var \Illuminate\Translation\Translator $instance */
7738: $instance->load($namespace, $group, $locale);
7739: }
7740: /**
7741: * Add a new namespace to the loader.
7742: *
7743: * @param string $namespace
7744: * @param string $hint
7745: * @return void
7746: * @static
7747: */
7748: public static function addNamespace($namespace, $hint)
7749: {
7750: /** @var \Illuminate\Translation\Translator $instance */
7751: $instance->addNamespace($namespace, $hint);
7752: }
7753: /**
7754: * Add a new JSON path to the loader.
7755: *
7756: * @param string $path
7757: * @return void
7758: * @static
7759: */
7760: public static function addJsonPath($path)
7761: {
7762: /** @var \Illuminate\Translation\Translator $instance */
7763: $instance->addJsonPath($path);
7764: }
7765: /**
7766: * Parse a key into namespace, group, and item.
7767: *
7768: * @param string $key
7769: * @return array
7770: * @static
7771: */
7772: public static function parseKey($key)
7773: {
7774: /** @var \Illuminate\Translation\Translator $instance */
7775: return $instance->parseKey($key);
7776: }
7777: /**
7778: * Specify a callback that should be invoked to determined the applicable locale array.
7779: *
7780: * @param callable $callback
7781: * @return void
7782: * @static
7783: */
7784: public static function determineLocalesUsing($callback)
7785: {
7786: /** @var \Illuminate\Translation\Translator $instance */
7787: $instance->determineLocalesUsing($callback);
7788: }
7789: /**
7790: * Get the message selector instance.
7791: *
7792: * @return \Illuminate\Translation\MessageSelector
7793: * @static
7794: */
7795: public static function getSelector()
7796: {
7797: /** @var \Illuminate\Translation\Translator $instance */
7798: return $instance->getSelector();
7799: }
7800: /**
7801: * Set the message selector instance.
7802: *
7803: * @param \Illuminate\Translation\MessageSelector $selector
7804: * @return void
7805: * @static
7806: */
7807: public static function setSelector($selector)
7808: {
7809: /** @var \Illuminate\Translation\Translator $instance */
7810: $instance->setSelector($selector);
7811: }
7812: /**
7813: * Get the language line loader implementation.
7814: *
7815: * @return \Illuminate\Contracts\Translation\Loader
7816: * @static
7817: */
7818: public static function getLoader()
7819: {
7820: /** @var \Illuminate\Translation\Translator $instance */
7821: return $instance->getLoader();
7822: }
7823: /**
7824: * Get the default locale being used.
7825: *
7826: * @return string
7827: * @static
7828: */
7829: public static function locale()
7830: {
7831: /** @var \Illuminate\Translation\Translator $instance */
7832: return $instance->locale();
7833: }
7834: /**
7835: * Get the default locale being used.
7836: *
7837: * @return string
7838: * @static
7839: */
7840: public static function getLocale()
7841: {
7842: /** @var \Illuminate\Translation\Translator $instance */
7843: return $instance->getLocale();
7844: }
7845: /**
7846: * Set the default locale.
7847: *
7848: * @param string $locale
7849: * @return void
7850: * @throws \InvalidArgumentException
7851: * @static
7852: */
7853: public static function setLocale($locale)
7854: {
7855: /** @var \Illuminate\Translation\Translator $instance */
7856: $instance->setLocale($locale);
7857: }
7858: /**
7859: * Get the fallback locale being used.
7860: *
7861: * @return string
7862: * @static
7863: */
7864: public static function getFallback()
7865: {
7866: /** @var \Illuminate\Translation\Translator $instance */
7867: return $instance->getFallback();
7868: }
7869: /**
7870: * Set the fallback locale being used.
7871: *
7872: * @param string $fallback
7873: * @return void
7874: * @static
7875: */
7876: public static function setFallback($fallback)
7877: {
7878: /** @var \Illuminate\Translation\Translator $instance */
7879: $instance->setFallback($fallback);
7880: }
7881: /**
7882: * Set the loaded translation groups.
7883: *
7884: * @param array $loaded
7885: * @return void
7886: * @static
7887: */
7888: public static function setLoaded($loaded)
7889: {
7890: /** @var \Illuminate\Translation\Translator $instance */
7891: $instance->setLoaded($loaded);
7892: }
7893: /**
7894: * Set the parsed value of a key.
7895: *
7896: * @param string $key
7897: * @param array $parsed
7898: * @return void
7899: * @static
7900: */
7901: public static function setParsedKey($key, $parsed)
7902: { //Method inherited from \Illuminate\Support\NamespacedItemResolver
7903: /** @var \Illuminate\Translation\Translator $instance */
7904: $instance->setParsedKey($key, $parsed);
7905: }
7906: /**
7907: * Flush the cache of parsed keys.
7908: *
7909: * @return void
7910: * @static
7911: */
7912: public static function flushParsedKeys()
7913: { //Method inherited from \Illuminate\Support\NamespacedItemResolver
7914: /** @var \Illuminate\Translation\Translator $instance */
7915: $instance->flushParsedKeys();
7916: }
7917: /**
7918: * Register a custom macro.
7919: *
7920: * @param string $name
7921: * @param object|callable $macro
7922: * @return void
7923: * @static
7924: */
7925: public static function macro($name, $macro)
7926: {
7927: \Illuminate\Translation\Translator::macro($name, $macro);
7928: }
7929: /**
7930: * Mix another object into the class.
7931: *
7932: * @param object $mixin
7933: * @param bool $replace
7934: * @return void
7935: * @throws \ReflectionException
7936: * @static
7937: */
7938: public static function mixin($mixin, $replace = true)
7939: {
7940: \Illuminate\Translation\Translator::mixin($mixin, $replace);
7941: }
7942: /**
7943: * Checks if macro is registered.
7944: *
7945: * @param string $name
7946: * @return bool
7947: * @static
7948: */
7949: public static function hasMacro($name)
7950: {
7951: return \Illuminate\Translation\Translator::hasMacro($name);
7952: }
7953: /**
7954: * Flush the existing macros.
7955: *
7956: * @return void
7957: * @static
7958: */
7959: public static function flushMacros()
7960: {
7961: \Illuminate\Translation\Translator::flushMacros();
7962: }
7963:
7964: }
7965: /**
7966: *
7967: *
7968: * @method static \Illuminate\Log\Logger withContext(array $context = [])
7969: * @method static \Illuminate\Log\Logger withoutContext()
7970: * @method static void write(string $level, string $message, array $context = [])
7971: * @method static void listen(\Closure $callback)
7972: * @see \Illuminate\Log\Logger
7973: */
7974: class Log {
7975: /**
7976: * Build an on-demand log channel.
7977: *
7978: * @param array $config
7979: * @return \Psr\Log\LoggerInterface
7980: * @static
7981: */
7982: public static function build($config)
7983: {
7984: /** @var \Illuminate\Log\LogManager $instance */
7985: return $instance->build($config);
7986: }
7987: /**
7988: * Create a new, on-demand aggregate logger instance.
7989: *
7990: * @param array $channels
7991: * @param string|null $channel
7992: * @return \Psr\Log\LoggerInterface
7993: * @static
7994: */
7995: public static function stack($channels, $channel = null)
7996: {
7997: /** @var \Illuminate\Log\LogManager $instance */
7998: return $instance->stack($channels, $channel);
7999: }
8000: /**
8001: * Get a log channel instance.
8002: *
8003: * @param string|null $channel
8004: * @return \Psr\Log\LoggerInterface
8005: * @static
8006: */
8007: public static function channel($channel = null)
8008: {
8009: /** @var \Illuminate\Log\LogManager $instance */
8010: return $instance->channel($channel);
8011: }
8012: /**
8013: * Get a log driver instance.
8014: *
8015: * @param string|null $driver
8016: * @return \Psr\Log\LoggerInterface
8017: * @static
8018: */
8019: public static function driver($driver = null)
8020: {
8021: /** @var \Illuminate\Log\LogManager $instance */
8022: return $instance->driver($driver);
8023: }
8024: /**
8025: * Share context across channels and stacks.
8026: *
8027: * @param array $context
8028: * @return \Illuminate\Log\LogManager
8029: * @static
8030: */
8031: public static function shareContext($context)
8032: {
8033: /** @var \Illuminate\Log\LogManager $instance */
8034: return $instance->shareContext($context);
8035: }
8036: /**
8037: * The context shared across channels and stacks.
8038: *
8039: * @return array
8040: * @static
8041: */
8042: public static function sharedContext()
8043: {
8044: /** @var \Illuminate\Log\LogManager $instance */
8045: return $instance->sharedContext();
8046: }
8047: /**
8048: * Flush the shared context.
8049: *
8050: * @return \Illuminate\Log\LogManager
8051: * @static
8052: */
8053: public static function flushSharedContext()
8054: {
8055: /** @var \Illuminate\Log\LogManager $instance */
8056: return $instance->flushSharedContext();
8057: }
8058: /**
8059: * Get the default log driver name.
8060: *
8061: * @return string|null
8062: * @static
8063: */
8064: public static function getDefaultDriver()
8065: {
8066: /** @var \Illuminate\Log\LogManager $instance */
8067: return $instance->getDefaultDriver();
8068: }
8069: /**
8070: * Set the default log driver name.
8071: *
8072: * @param string $name
8073: * @return void
8074: * @static
8075: */
8076: public static function setDefaultDriver($name)
8077: {
8078: /** @var \Illuminate\Log\LogManager $instance */
8079: $instance->setDefaultDriver($name);
8080: }
8081: /**
8082: * Register a custom driver creator Closure.
8083: *
8084: * @param string $driver
8085: * @param \Closure $callback
8086: * @return \Illuminate\Log\LogManager
8087: * @static
8088: */
8089: public static function extend($driver, $callback)
8090: {
8091: /** @var \Illuminate\Log\LogManager $instance */
8092: return $instance->extend($driver, $callback);
8093: }
8094: /**
8095: * Unset the given channel instance.
8096: *
8097: * @param string|null $driver
8098: * @return \Illuminate\Log\LogManager
8099: * @static
8100: */
8101: public static function forgetChannel($driver = null)
8102: {
8103: /** @var \Illuminate\Log\LogManager $instance */
8104: return $instance->forgetChannel($driver);
8105: }
8106: /**
8107: * Get all of the resolved log channels.
8108: *
8109: * @return array
8110: * @static
8111: */
8112: public static function getChannels()
8113: {
8114: /** @var \Illuminate\Log\LogManager $instance */
8115: return $instance->getChannels();
8116: }
8117: /**
8118: * System is unusable.
8119: *
8120: * @param string $message
8121: * @param array $context
8122: * @return void
8123: * @static
8124: */
8125: public static function emergency($message, $context = [])
8126: {
8127: /** @var \Illuminate\Log\LogManager $instance */
8128: $instance->emergency($message, $context);
8129: }
8130: /**
8131: * Action must be taken immediately.
8132: *
8133: * Example: Entire website down, database unavailable, etc. This should
8134: * trigger the SMS alerts and wake you up.
8135: *
8136: * @param string $message
8137: * @param array $context
8138: * @return void
8139: * @static
8140: */
8141: public static function alert($message, $context = [])
8142: {
8143: /** @var \Illuminate\Log\LogManager $instance */
8144: $instance->alert($message, $context);
8145: }
8146: /**
8147: * Critical conditions.
8148: *
8149: * Example: Application component unavailable, unexpected exception.
8150: *
8151: * @param string $message
8152: * @param array $context
8153: * @return void
8154: * @static
8155: */
8156: public static function critical($message, $context = [])
8157: {
8158: /** @var \Illuminate\Log\LogManager $instance */
8159: $instance->critical($message, $context);
8160: }
8161: /**
8162: * Runtime errors that do not require immediate action but should typically
8163: * be logged and monitored.
8164: *
8165: * @param string $message
8166: * @param array $context
8167: * @return void
8168: * @static
8169: */
8170: public static function error($message, $context = [])
8171: {
8172: /** @var \Illuminate\Log\LogManager $instance */
8173: $instance->error($message, $context);
8174: }
8175: /**
8176: * Exceptional occurrences that are not errors.
8177: *
8178: * Example: Use of deprecated APIs, poor use of an API, undesirable things
8179: * that are not necessarily wrong.
8180: *
8181: * @param string $message
8182: * @param array $context
8183: * @return void
8184: * @static
8185: */
8186: public static function warning($message, $context = [])
8187: {
8188: /** @var \Illuminate\Log\LogManager $instance */
8189: $instance->warning($message, $context);
8190: }
8191: /**
8192: * Normal but significant events.
8193: *
8194: * @param string $message
8195: * @param array $context
8196: * @return void
8197: * @static
8198: */
8199: public static function notice($message, $context = [])
8200: {
8201: /** @var \Illuminate\Log\LogManager $instance */
8202: $instance->notice($message, $context);
8203: }
8204: /**
8205: * Interesting events.
8206: *
8207: * Example: User logs in, SQL logs.
8208: *
8209: * @param string $message
8210: * @param array $context
8211: * @return void
8212: * @static
8213: */
8214: public static function info($message, $context = [])
8215: {
8216: /** @var \Illuminate\Log\LogManager $instance */
8217: $instance->info($message, $context);
8218: }
8219: /**
8220: * Detailed debug information.
8221: *
8222: * @param string $message
8223: * @param array $context
8224: * @return void
8225: * @static
8226: */
8227: public static function debug($message, $context = [])
8228: {
8229: /** @var \Illuminate\Log\LogManager $instance */
8230: $instance->debug($message, $context);
8231: }
8232: /**
8233: * Logs with an arbitrary level.
8234: *
8235: * @param mixed $level
8236: * @param string $message
8237: * @param array $context
8238: * @return void
8239: * @static
8240: */
8241: public static function log($level, $message, $context = [])
8242: {
8243: /** @var \Illuminate\Log\LogManager $instance */
8244: $instance->log($level, $message, $context);
8245: }
8246:
8247: }
8248: /**
8249: *
8250: *
8251: * @method static void alwaysFrom(string $address, string|null $name = null)
8252: * @method static void alwaysReplyTo(string $address, string|null $name = null)
8253: * @method static void alwaysReturnPath(string $address)
8254: * @method static void alwaysTo(string $address, string|null $name = null)
8255: * @method static \Illuminate\Mail\SentMessage|null plain(string $view, array $data, $callback)
8256: * @method static \Illuminate\Mail\SentMessage|null html(string $html, $callback)
8257: * @method static mixed laterOn(string $queue, \DateTimeInterface|\DateInterval|int $delay, \Illuminate\Contracts\Mail\Mailable|string|array $view)
8258: * @method static mixed queueOn(string $queue, \Illuminate\Contracts\Mail\Mailable|string|array $view)
8259: * @see \Illuminate\Mail\Mailer
8260: * @see \Illuminate\Support\Testing\Fakes\MailFake
8261: */
8262: class Mail {
8263: /**
8264: * Get a mailer instance by name.
8265: *
8266: * @param string|null $name
8267: * @return \Illuminate\Contracts\Mail\Mailer
8268: * @static
8269: */
8270: public static function mailer($name = null)
8271: {
8272: /** @var \Illuminate\Mail\MailManager $instance */
8273: return $instance->mailer($name);
8274: }
8275: /**
8276: * Get a mailer driver instance.
8277: *
8278: * @param string|null $driver
8279: * @return \Illuminate\Mail\Mailer
8280: * @static
8281: */
8282: public static function driver($driver = null)
8283: {
8284: /** @var \Illuminate\Mail\MailManager $instance */
8285: return $instance->driver($driver);
8286: }
8287: /**
8288: * Create a new transport instance.
8289: *
8290: * @param array $config
8291: * @return \Symfony\Component\Mailer\Transport\TransportInterface
8292: * @throws \InvalidArgumentException
8293: * @static
8294: */
8295: public static function createSymfonyTransport($config)
8296: {
8297: /** @var \Illuminate\Mail\MailManager $instance */
8298: return $instance->createSymfonyTransport($config);
8299: }
8300: /**
8301: * Get the default mail driver name.
8302: *
8303: * @return string
8304: * @static
8305: */
8306: public static function getDefaultDriver()
8307: {
8308: /** @var \Illuminate\Mail\MailManager $instance */
8309: return $instance->getDefaultDriver();
8310: }
8311: /**
8312: * Set the default mail driver name.
8313: *
8314: * @param string $name
8315: * @return void
8316: * @static
8317: */
8318: public static function setDefaultDriver($name)
8319: {
8320: /** @var \Illuminate\Mail\MailManager $instance */
8321: $instance->setDefaultDriver($name);
8322: }
8323: /**
8324: * Disconnect the given mailer and remove from local cache.
8325: *
8326: * @param string|null $name
8327: * @return void
8328: * @static
8329: */
8330: public static function purge($name = null)
8331: {
8332: /** @var \Illuminate\Mail\MailManager $instance */
8333: $instance->purge($name);
8334: }
8335: /**
8336: * Register a custom transport creator Closure.
8337: *
8338: * @param string $driver
8339: * @param \Closure $callback
8340: * @return \Illuminate\Mail\MailManager
8341: * @static
8342: */
8343: public static function extend($driver, $callback)
8344: {
8345: /** @var \Illuminate\Mail\MailManager $instance */
8346: return $instance->extend($driver, $callback);
8347: }
8348: /**
8349: * Get the application instance used by the manager.
8350: *
8351: * @return \Illuminate\Contracts\Foundation\Application
8352: * @static
8353: */
8354: public static function getApplication()
8355: {
8356: /** @var \Illuminate\Mail\MailManager $instance */
8357: return $instance->getApplication();
8358: }
8359: /**
8360: * Set the application instance used by the manager.
8361: *
8362: * @param \Illuminate\Contracts\Foundation\Application $app
8363: * @return \Illuminate\Mail\MailManager
8364: * @static
8365: */
8366: public static function setApplication($app)
8367: {
8368: /** @var \Illuminate\Mail\MailManager $instance */
8369: return $instance->setApplication($app);
8370: }
8371: /**
8372: * Forget all of the resolved mailer instances.
8373: *
8374: * @return \Illuminate\Mail\MailManager
8375: * @static
8376: */
8377: public static function forgetMailers()
8378: {
8379: /** @var \Illuminate\Mail\MailManager $instance */
8380: return $instance->forgetMailers();
8381: }
8382: /**
8383: * Assert if a mailable was sent based on a truth-test callback.
8384: *
8385: * @param string|\Closure $mailable
8386: * @param callable|int|null $callback
8387: * @return void
8388: * @static
8389: */
8390: public static function assertSent($mailable, $callback = null)
8391: {
8392: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8393: $instance->assertSent($mailable, $callback);
8394: }
8395: /**
8396: * Determine if a mailable was not sent or queued to be sent based on a truth-test callback.
8397: *
8398: * @param string|\Closure $mailable
8399: * @param callable|null $callback
8400: * @return void
8401: * @static
8402: */
8403: public static function assertNotOutgoing($mailable, $callback = null)
8404: {
8405: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8406: $instance->assertNotOutgoing($mailable, $callback);
8407: }
8408: /**
8409: * Determine if a mailable was not sent based on a truth-test callback.
8410: *
8411: * @param string|\Closure $mailable
8412: * @param callable|null $callback
8413: * @return void
8414: * @static
8415: */
8416: public static function assertNotSent($mailable, $callback = null)
8417: {
8418: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8419: $instance->assertNotSent($mailable, $callback);
8420: }
8421: /**
8422: * Assert that no mailables were sent or queued to be sent.
8423: *
8424: * @return void
8425: * @static
8426: */
8427: public static function assertNothingOutgoing()
8428: {
8429: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8430: $instance->assertNothingOutgoing();
8431: }
8432: /**
8433: * Assert that no mailables were sent.
8434: *
8435: * @return void
8436: * @static
8437: */
8438: public static function assertNothingSent()
8439: {
8440: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8441: $instance->assertNothingSent();
8442: }
8443: /**
8444: * Assert if a mailable was queued based on a truth-test callback.
8445: *
8446: * @param string|\Closure $mailable
8447: * @param callable|int|null $callback
8448: * @return void
8449: * @static
8450: */
8451: public static function assertQueued($mailable, $callback = null)
8452: {
8453: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8454: $instance->assertQueued($mailable, $callback);
8455: }
8456: /**
8457: * Determine if a mailable was not queued based on a truth-test callback.
8458: *
8459: * @param string|\Closure $mailable
8460: * @param callable|null $callback
8461: * @return void
8462: * @static
8463: */
8464: public static function assertNotQueued($mailable, $callback = null)
8465: {
8466: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8467: $instance->assertNotQueued($mailable, $callback);
8468: }
8469: /**
8470: * Assert that no mailables were queued.
8471: *
8472: * @return void
8473: * @static
8474: */
8475: public static function assertNothingQueued()
8476: {
8477: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8478: $instance->assertNothingQueued();
8479: }
8480: /**
8481: * Get all of the mailables matching a truth-test callback.
8482: *
8483: * @param string|\Closure $mailable
8484: * @param callable|null $callback
8485: * @return \Illuminate\Support\Collection
8486: * @static
8487: */
8488: public static function sent($mailable, $callback = null)
8489: {
8490: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8491: return $instance->sent($mailable, $callback);
8492: }
8493: /**
8494: * Determine if the given mailable has been sent.
8495: *
8496: * @param string $mailable
8497: * @return bool
8498: * @static
8499: */
8500: public static function hasSent($mailable)
8501: {
8502: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8503: return $instance->hasSent($mailable);
8504: }
8505: /**
8506: * Get all of the queued mailables matching a truth-test callback.
8507: *
8508: * @param string|\Closure $mailable
8509: * @param callable|null $callback
8510: * @return \Illuminate\Support\Collection
8511: * @static
8512: */
8513: public static function queued($mailable, $callback = null)
8514: {
8515: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8516: return $instance->queued($mailable, $callback);
8517: }
8518: /**
8519: * Determine if the given mailable has been queued.
8520: *
8521: * @param string $mailable
8522: * @return bool
8523: * @static
8524: */
8525: public static function hasQueued($mailable)
8526: {
8527: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8528: return $instance->hasQueued($mailable);
8529: }
8530: /**
8531: * Begin the process of mailing a mailable class instance.
8532: *
8533: * @param mixed $users
8534: * @return \Illuminate\Mail\PendingMail
8535: * @static
8536: */
8537: public static function to($users)
8538: {
8539: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8540: return $instance->to($users);
8541: }
8542: /**
8543: * Begin the process of mailing a mailable class instance.
8544: *
8545: * @param mixed $users
8546: * @return \Illuminate\Mail\PendingMail
8547: * @static
8548: */
8549: public static function bcc($users)
8550: {
8551: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8552: return $instance->bcc($users);
8553: }
8554: /**
8555: * Send a new message with only a raw text part.
8556: *
8557: * @param string $text
8558: * @param \Closure|string $callback
8559: * @return void
8560: * @static
8561: */
8562: public static function raw($text, $callback)
8563: {
8564: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8565: $instance->raw($text, $callback);
8566: }
8567: /**
8568: * Send a new message using a view.
8569: *
8570: * @param \Illuminate\Contracts\Mail\Mailable|string|array $view
8571: * @param array $data
8572: * @param \Closure|string|null $callback
8573: * @return void
8574: * @static
8575: */
8576: public static function send($view, $data = [], $callback = null)
8577: {
8578: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8579: $instance->send($view, $data, $callback);
8580: }
8581: /**
8582: * Queue a new e-mail message for sending.
8583: *
8584: * @param \Illuminate\Contracts\Mail\Mailable|string|array $view
8585: * @param string|null $queue
8586: * @return mixed
8587: * @static
8588: */
8589: public static function queue($view, $queue = null)
8590: {
8591: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8592: return $instance->queue($view, $queue);
8593: }
8594: /**
8595: * Queue a new e-mail message for sending after (n) seconds.
8596: *
8597: * @param \DateTimeInterface|\DateInterval|int $delay
8598: * @param \Illuminate\Contracts\Mail\Mailable|string|array $view
8599: * @param string|null $queue
8600: * @return mixed
8601: * @static
8602: */
8603: public static function later($delay, $view, $queue = null)
8604: {
8605: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8606: return $instance->later($delay, $view, $queue);
8607: }
8608: /**
8609: * Get the array of failed recipients.
8610: *
8611: * @return array
8612: * @static
8613: */
8614: public static function failures()
8615: {
8616: /** @var \Illuminate\Support\Testing\Fakes\MailFake $instance */
8617: return $instance->failures();
8618: }
8619:
8620: }
8621: /**
8622: *
8623: *
8624: * @see \Illuminate\Notifications\ChannelManager
8625: */
8626: class Notification {
8627: /**
8628: * Send the given notification to the given notifiable entities.
8629: *
8630: * @param \Illuminate\Support\Collection|array|mixed $notifiables
8631: * @param mixed $notification
8632: * @return void
8633: * @static
8634: */
8635: public static function send($notifiables, $notification)
8636: {
8637: /** @var \Illuminate\Notifications\ChannelManager $instance */
8638: $instance->send($notifiables, $notification);
8639: }
8640: /**
8641: * Send the given notification immediately.
8642: *
8643: * @param \Illuminate\Support\Collection|array|mixed $notifiables
8644: * @param mixed $notification
8645: * @param array|null $channels
8646: * @return void
8647: * @static
8648: */
8649: public static function sendNow($notifiables, $notification, $channels = null)
8650: {
8651: /** @var \Illuminate\Notifications\ChannelManager $instance */
8652: $instance->sendNow($notifiables, $notification, $channels);
8653: }
8654: /**
8655: * Get a channel instance.
8656: *
8657: * @param string|null $name
8658: * @return mixed
8659: * @static
8660: */
8661: public static function channel($name = null)
8662: {
8663: /** @var \Illuminate\Notifications\ChannelManager $instance */
8664: return $instance->channel($name);
8665: }
8666: /**
8667: * Get the default channel driver name.
8668: *
8669: * @return string
8670: * @static
8671: */
8672: public static function getDefaultDriver()
8673: {
8674: /** @var \Illuminate\Notifications\ChannelManager $instance */
8675: return $instance->getDefaultDriver();
8676: }
8677: /**
8678: * Get the default channel driver name.
8679: *
8680: * @return string
8681: * @static
8682: */
8683: public static function deliversVia()
8684: {
8685: /** @var \Illuminate\Notifications\ChannelManager $instance */
8686: return $instance->deliversVia();
8687: }
8688: /**
8689: * Set the default channel driver name.
8690: *
8691: * @param string $channel
8692: * @return void
8693: * @static
8694: */
8695: public static function deliverVia($channel)
8696: {
8697: /** @var \Illuminate\Notifications\ChannelManager $instance */
8698: $instance->deliverVia($channel);
8699: }
8700: /**
8701: * Set the locale of notifications.
8702: *
8703: * @param string $locale
8704: * @return \Illuminate\Notifications\ChannelManager
8705: * @static
8706: */
8707: public static function locale($locale)
8708: {
8709: /** @var \Illuminate\Notifications\ChannelManager $instance */
8710: return $instance->locale($locale);
8711: }
8712: /**
8713: * Get a driver instance.
8714: *
8715: * @param string|null $driver
8716: * @return mixed
8717: * @throws \InvalidArgumentException
8718: * @static
8719: */
8720: public static function driver($driver = null)
8721: { //Method inherited from \Illuminate\Support\Manager
8722: /** @var \Illuminate\Notifications\ChannelManager $instance */
8723: return $instance->driver($driver);
8724: }
8725: /**
8726: * Register a custom driver creator Closure.
8727: *
8728: * @param string $driver
8729: * @param \Closure $callback
8730: * @return \Illuminate\Notifications\ChannelManager
8731: * @static
8732: */
8733: public static function extend($driver, $callback)
8734: { //Method inherited from \Illuminate\Support\Manager
8735: /** @var \Illuminate\Notifications\ChannelManager $instance */
8736: return $instance->extend($driver, $callback);
8737: }
8738: /**
8739: * Get all of the created "drivers".
8740: *
8741: * @return array
8742: * @static
8743: */
8744: public static function getDrivers()
8745: { //Method inherited from \Illuminate\Support\Manager
8746: /** @var \Illuminate\Notifications\ChannelManager $instance */
8747: return $instance->getDrivers();
8748: }
8749: /**
8750: * Get the container instance used by the manager.
8751: *
8752: * @return \Illuminate\Contracts\Container\Container
8753: * @static
8754: */
8755: public static function getContainer()
8756: { //Method inherited from \Illuminate\Support\Manager
8757: /** @var \Illuminate\Notifications\ChannelManager $instance */
8758: return $instance->getContainer();
8759: }
8760: /**
8761: * Set the container instance used by the manager.
8762: *
8763: * @param \Illuminate\Contracts\Container\Container $container
8764: * @return \Illuminate\Notifications\ChannelManager
8765: * @static
8766: */
8767: public static function setContainer($container)
8768: { //Method inherited from \Illuminate\Support\Manager
8769: /** @var \Illuminate\Notifications\ChannelManager $instance */
8770: return $instance->setContainer($container);
8771: }
8772: /**
8773: * Forget all of the resolved driver instances.
8774: *
8775: * @return \Illuminate\Notifications\ChannelManager
8776: * @static
8777: */
8778: public static function forgetDrivers()
8779: { //Method inherited from \Illuminate\Support\Manager
8780: /** @var \Illuminate\Notifications\ChannelManager $instance */
8781: return $instance->forgetDrivers();
8782: }
8783: /**
8784: * Assert if a notification was sent on-demand based on a truth-test callback.
8785: *
8786: * @param string|\Closure $notification
8787: * @param callable|null $callback
8788: * @return void
8789: * @throws \Exception
8790: * @static
8791: */
8792: public static function assertSentOnDemand($notification, $callback = null)
8793: {
8794: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8795: $instance->assertSentOnDemand($notification, $callback);
8796: }
8797: /**
8798: * Assert if a notification was sent based on a truth-test callback.
8799: *
8800: * @param mixed $notifiable
8801: * @param string|\Closure $notification
8802: * @param callable|null $callback
8803: * @return void
8804: * @throws \Exception
8805: * @static
8806: */
8807: public static function assertSentTo($notifiable, $notification, $callback = null)
8808: {
8809: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8810: $instance->assertSentTo($notifiable, $notification, $callback);
8811: }
8812: /**
8813: * Assert if a notification was sent on-demand a number of times.
8814: *
8815: * @param string $notification
8816: * @param int $times
8817: * @return void
8818: * @static
8819: */
8820: public static function assertSentOnDemandTimes($notification, $times = 1)
8821: {
8822: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8823: $instance->assertSentOnDemandTimes($notification, $times);
8824: }
8825: /**
8826: * Assert if a notification was sent a number of times.
8827: *
8828: * @param mixed $notifiable
8829: * @param string $notification
8830: * @param int $times
8831: * @return void
8832: * @static
8833: */
8834: public static function assertSentToTimes($notifiable, $notification, $times = 1)
8835: {
8836: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8837: $instance->assertSentToTimes($notifiable, $notification, $times);
8838: }
8839: /**
8840: * Determine if a notification was sent based on a truth-test callback.
8841: *
8842: * @param mixed $notifiable
8843: * @param string|\Closure $notification
8844: * @param callable|null $callback
8845: * @return void
8846: * @throws \Exception
8847: * @static
8848: */
8849: public static function assertNotSentTo($notifiable, $notification, $callback = null)
8850: {
8851: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8852: $instance->assertNotSentTo($notifiable, $notification, $callback);
8853: }
8854: /**
8855: * Assert that no notifications were sent.
8856: *
8857: * @return void
8858: * @static
8859: */
8860: public static function assertNothingSent()
8861: {
8862: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8863: $instance->assertNothingSent();
8864: }
8865: /**
8866: * Assert that no notifications were sent to the given notifiable.
8867: *
8868: * @param mixed $notifiable
8869: * @return void
8870: * @throws \Exception
8871: * @static
8872: */
8873: public static function assertNothingSentTo($notifiable)
8874: {
8875: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8876: $instance->assertNothingSentTo($notifiable);
8877: }
8878: /**
8879: * Assert the total amount of times a notification was sent.
8880: *
8881: * @param string $notification
8882: * @param int $expectedCount
8883: * @return void
8884: * @static
8885: */
8886: public static function assertSentTimes($notification, $expectedCount)
8887: {
8888: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8889: $instance->assertSentTimes($notification, $expectedCount);
8890: }
8891: /**
8892: * Assert the total count of notification that were sent.
8893: *
8894: * @param int $expectedCount
8895: * @return void
8896: * @static
8897: */
8898: public static function assertCount($expectedCount)
8899: {
8900: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8901: $instance->assertCount($expectedCount);
8902: }
8903: /**
8904: * Assert the total amount of times a notification was sent.
8905: *
8906: * @param int $expectedCount
8907: * @param string $notification
8908: * @return void
8909: * @deprecated Use the assertSentTimes method instead
8910: * @static
8911: */
8912: public static function assertTimesSent($expectedCount, $notification)
8913: {
8914: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8915: $instance->assertTimesSent($expectedCount, $notification);
8916: }
8917: /**
8918: * Get all of the notifications matching a truth-test callback.
8919: *
8920: * @param mixed $notifiable
8921: * @param string $notification
8922: * @param callable|null $callback
8923: * @return \Illuminate\Support\Collection
8924: * @static
8925: */
8926: public static function sent($notifiable, $notification, $callback = null)
8927: {
8928: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8929: return $instance->sent($notifiable, $notification, $callback);
8930: }
8931: /**
8932: * Determine if there are more notifications left to inspect.
8933: *
8934: * @param mixed $notifiable
8935: * @param string $notification
8936: * @return bool
8937: * @static
8938: */
8939: public static function hasSent($notifiable, $notification)
8940: {
8941: /** @var \Illuminate\Support\Testing\Fakes\NotificationFake $instance */
8942: return $instance->hasSent($notifiable, $notification);
8943: }
8944: /**
8945: * Register a custom macro.
8946: *
8947: * @param string $name
8948: * @param object|callable $macro
8949: * @return void
8950: * @static
8951: */
8952: public static function macro($name, $macro)
8953: {
8954: \Illuminate\Support\Testing\Fakes\NotificationFake::macro($name, $macro);
8955: }
8956: /**
8957: * Mix another object into the class.
8958: *
8959: * @param object $mixin
8960: * @param bool $replace
8961: * @return void
8962: * @throws \ReflectionException
8963: * @static
8964: */
8965: public static function mixin($mixin, $replace = true)
8966: {
8967: \Illuminate\Support\Testing\Fakes\NotificationFake::mixin($mixin, $replace);
8968: }
8969: /**
8970: * Checks if macro is registered.
8971: *
8972: * @param string $name
8973: * @return bool
8974: * @static
8975: */
8976: public static function hasMacro($name)
8977: {
8978: return \Illuminate\Support\Testing\Fakes\NotificationFake::hasMacro($name);
8979: }
8980: /**
8981: * Flush the existing macros.
8982: *
8983: * @return void
8984: * @static
8985: */
8986: public static function flushMacros()
8987: {
8988: \Illuminate\Support\Testing\Fakes\NotificationFake::flushMacros();
8989: }
8990:
8991: }
8992: /**
8993: *
8994: *
8995: * @method static mixed reset(array $credentials, \Closure $callback)
8996: * @method static string sendResetLink(array $credentials, \Closure $callback = null)
8997: * @method static \Illuminate\Contracts\Auth\CanResetPassword getUser(array $credentials)
8998: * @method static string createToken(\Illuminate\Contracts\Auth\CanResetPassword $user)
8999: * @method static void deleteToken(\Illuminate\Contracts\Auth\CanResetPassword $user)
9000: * @method static bool tokenExists(\Illuminate\Contracts\Auth\CanResetPassword $user, string $token)
9001: * @method static \Illuminate\Auth\Passwords\TokenRepositoryInterface getRepository()
9002: * @see \Illuminate\Auth\Passwords\PasswordBroker
9003: */
9004: class Password {
9005: /**
9006: * Attempt to get the broker from the local cache.
9007: *
9008: * @param string|null $name
9009: * @return \Illuminate\Contracts\Auth\PasswordBroker
9010: * @static
9011: */
9012: public static function broker($name = null)
9013: {
9014: /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */
9015: return $instance->broker($name);
9016: }
9017: /**
9018: * Get the default password broker name.
9019: *
9020: * @return string
9021: * @static
9022: */
9023: public static function getDefaultDriver()
9024: {
9025: /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */
9026: return $instance->getDefaultDriver();
9027: }
9028: /**
9029: * Set the default password broker name.
9030: *
9031: * @param string $name
9032: * @return void
9033: * @static
9034: */
9035: public static function setDefaultDriver($name)
9036: {
9037: /** @var \Illuminate\Auth\Passwords\PasswordBrokerManager $instance */
9038: $instance->setDefaultDriver($name);
9039: }
9040:
9041: }
9042: /**
9043: *
9044: *
9045: * @see \Illuminate\Queue\QueueManager
9046: * @see \Illuminate\Queue\Queue
9047: */
9048: class Queue {
9049: /**
9050: * Register an event listener for the before job event.
9051: *
9052: * @param mixed $callback
9053: * @return void
9054: * @static
9055: */
9056: public static function before($callback)
9057: {
9058: /** @var \Illuminate\Queue\QueueManager $instance */
9059: $instance->before($callback);
9060: }
9061: /**
9062: * Register an event listener for the after job event.
9063: *
9064: * @param mixed $callback
9065: * @return void
9066: * @static
9067: */
9068: public static function after($callback)
9069: {
9070: /** @var \Illuminate\Queue\QueueManager $instance */
9071: $instance->after($callback);
9072: }
9073: /**
9074: * Register an event listener for the exception occurred job event.
9075: *
9076: * @param mixed $callback
9077: * @return void
9078: * @static
9079: */
9080: public static function exceptionOccurred($callback)
9081: {
9082: /** @var \Illuminate\Queue\QueueManager $instance */
9083: $instance->exceptionOccurred($callback);
9084: }
9085: /**
9086: * Register an event listener for the daemon queue loop.
9087: *
9088: * @param mixed $callback
9089: * @return void
9090: * @static
9091: */
9092: public static function looping($callback)
9093: {
9094: /** @var \Illuminate\Queue\QueueManager $instance */
9095: $instance->looping($callback);
9096: }
9097: /**
9098: * Register an event listener for the failed job event.
9099: *
9100: * @param mixed $callback
9101: * @return void
9102: * @static
9103: */
9104: public static function failing($callback)
9105: {
9106: /** @var \Illuminate\Queue\QueueManager $instance */
9107: $instance->failing($callback);
9108: }
9109: /**
9110: * Register an event listener for the daemon queue stopping.
9111: *
9112: * @param mixed $callback
9113: * @return void
9114: * @static
9115: */
9116: public static function stopping($callback)
9117: {
9118: /** @var \Illuminate\Queue\QueueManager $instance */
9119: $instance->stopping($callback);
9120: }
9121: /**
9122: * Determine if the driver is connected.
9123: *
9124: * @param string|null $name
9125: * @return bool
9126: * @static
9127: */
9128: public static function connected($name = null)
9129: {
9130: /** @var \Illuminate\Queue\QueueManager $instance */
9131: return $instance->connected($name);
9132: }
9133: /**
9134: * Resolve a queue connection instance.
9135: *
9136: * @param string|null $name
9137: * @return \Illuminate\Contracts\Queue\Queue
9138: * @static
9139: */
9140: public static function connection($name = null)
9141: {
9142: /** @var \Illuminate\Queue\QueueManager $instance */
9143: return $instance->connection($name);
9144: }
9145: /**
9146: * Add a queue connection resolver.
9147: *
9148: * @param string $driver
9149: * @param \Closure $resolver
9150: * @return void
9151: * @static
9152: */
9153: public static function extend($driver, $resolver)
9154: {
9155: /** @var \Illuminate\Queue\QueueManager $instance */
9156: $instance->extend($driver, $resolver);
9157: }
9158: /**
9159: * Add a queue connection resolver.
9160: *
9161: * @param string $driver
9162: * @param \Closure $resolver
9163: * @return void
9164: * @static
9165: */
9166: public static function addConnector($driver, $resolver)
9167: {
9168: /** @var \Illuminate\Queue\QueueManager $instance */
9169: $instance->addConnector($driver, $resolver);
9170: }
9171: /**
9172: * Get the name of the default queue connection.
9173: *
9174: * @return string
9175: * @static
9176: */
9177: public static function getDefaultDriver()
9178: {
9179: /** @var \Illuminate\Queue\QueueManager $instance */
9180: return $instance->getDefaultDriver();
9181: }
9182: /**
9183: * Set the name of the default queue connection.
9184: *
9185: * @param string $name
9186: * @return void
9187: * @static
9188: */
9189: public static function setDefaultDriver($name)
9190: {
9191: /** @var \Illuminate\Queue\QueueManager $instance */
9192: $instance->setDefaultDriver($name);
9193: }
9194: /**
9195: * Get the full name for the given connection.
9196: *
9197: * @param string|null $connection
9198: * @return string
9199: * @static
9200: */
9201: public static function getName($connection = null)
9202: {
9203: /** @var \Illuminate\Queue\QueueManager $instance */
9204: return $instance->getName($connection);
9205: }
9206: /**
9207: * Get the application instance used by the manager.
9208: *
9209: * @return \Illuminate\Contracts\Foundation\Application
9210: * @static
9211: */
9212: public static function getApplication()
9213: {
9214: /** @var \Illuminate\Queue\QueueManager $instance */
9215: return $instance->getApplication();
9216: }
9217: /**
9218: * Set the application instance used by the manager.
9219: *
9220: * @param \Illuminate\Contracts\Foundation\Application $app
9221: * @return \Illuminate\Queue\QueueManager
9222: * @static
9223: */
9224: public static function setApplication($app)
9225: {
9226: /** @var \Illuminate\Queue\QueueManager $instance */
9227: return $instance->setApplication($app);
9228: }
9229: /**
9230: * Assert if a job was pushed based on a truth-test callback.
9231: *
9232: * @param string|\Closure $job
9233: * @param callable|int|null $callback
9234: * @return void
9235: * @static
9236: */
9237: public static function assertPushed($job, $callback = null)
9238: {
9239: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9240: $instance->assertPushed($job, $callback);
9241: }
9242: /**
9243: * Assert if a job was pushed based on a truth-test callback.
9244: *
9245: * @param string $queue
9246: * @param string|\Closure $job
9247: * @param callable|null $callback
9248: * @return void
9249: * @static
9250: */
9251: public static function assertPushedOn($queue, $job, $callback = null)
9252: {
9253: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9254: $instance->assertPushedOn($queue, $job, $callback);
9255: }
9256: /**
9257: * Assert if a job was pushed with chained jobs based on a truth-test callback.
9258: *
9259: * @param string $job
9260: * @param array $expectedChain
9261: * @param callable|null $callback
9262: * @return void
9263: * @static
9264: */
9265: public static function assertPushedWithChain($job, $expectedChain = [], $callback = null)
9266: {
9267: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9268: $instance->assertPushedWithChain($job, $expectedChain, $callback);
9269: }
9270: /**
9271: * Assert if a job was pushed with an empty chain based on a truth-test callback.
9272: *
9273: * @param string $job
9274: * @param callable|null $callback
9275: * @return void
9276: * @static
9277: */
9278: public static function assertPushedWithoutChain($job, $callback = null)
9279: {
9280: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9281: $instance->assertPushedWithoutChain($job, $callback);
9282: }
9283: /**
9284: * Determine if a job was pushed based on a truth-test callback.
9285: *
9286: * @param string|\Closure $job
9287: * @param callable|null $callback
9288: * @return void
9289: * @static
9290: */
9291: public static function assertNotPushed($job, $callback = null)
9292: {
9293: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9294: $instance->assertNotPushed($job, $callback);
9295: }
9296: /**
9297: * Assert that no jobs were pushed.
9298: *
9299: * @return void
9300: * @static
9301: */
9302: public static function assertNothingPushed()
9303: {
9304: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9305: $instance->assertNothingPushed();
9306: }
9307: /**
9308: * Get all of the jobs matching a truth-test callback.
9309: *
9310: * @param string $job
9311: * @param callable|null $callback
9312: * @return \Illuminate\Support\Collection
9313: * @static
9314: */
9315: public static function pushed($job, $callback = null)
9316: {
9317: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9318: return $instance->pushed($job, $callback);
9319: }
9320: /**
9321: * Determine if there are any stored jobs for a given class.
9322: *
9323: * @param string $job
9324: * @return bool
9325: * @static
9326: */
9327: public static function hasPushed($job)
9328: {
9329: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9330: return $instance->hasPushed($job);
9331: }
9332: /**
9333: * Get the size of the queue.
9334: *
9335: * @param string|null $queue
9336: * @return int
9337: * @static
9338: */
9339: public static function size($queue = null)
9340: {
9341: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9342: return $instance->size($queue);
9343: }
9344: /**
9345: * Push a new job onto the queue.
9346: *
9347: * @param string|object $job
9348: * @param mixed $data
9349: * @param string|null $queue
9350: * @return mixed
9351: * @static
9352: */
9353: public static function push($job, $data = '', $queue = null)
9354: {
9355: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9356: return $instance->push($job, $data, $queue);
9357: }
9358: /**
9359: * Determine if a job should be faked or actually dispatched.
9360: *
9361: * @param object $job
9362: * @return bool
9363: * @static
9364: */
9365: public static function shouldFakeJob($job)
9366: {
9367: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9368: return $instance->shouldFakeJob($job);
9369: }
9370: /**
9371: * Push a raw payload onto the queue.
9372: *
9373: * @param string $payload
9374: * @param string|null $queue
9375: * @param array $options
9376: * @return mixed
9377: * @static
9378: */
9379: public static function pushRaw($payload, $queue = null, $options = [])
9380: {
9381: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9382: return $instance->pushRaw($payload, $queue, $options);
9383: }
9384: /**
9385: * Push a new job onto the queue after (n) seconds.
9386: *
9387: * @param \DateTimeInterface|\DateInterval|int $delay
9388: * @param string|object $job
9389: * @param mixed $data
9390: * @param string|null $queue
9391: * @return mixed
9392: * @static
9393: */
9394: public static function later($delay, $job, $data = '', $queue = null)
9395: {
9396: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9397: return $instance->later($delay, $job, $data, $queue);
9398: }
9399: /**
9400: * Push a new job onto the queue.
9401: *
9402: * @param string $queue
9403: * @param string|object $job
9404: * @param mixed $data
9405: * @return mixed
9406: * @static
9407: */
9408: public static function pushOn($queue, $job, $data = '')
9409: {
9410: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9411: return $instance->pushOn($queue, $job, $data);
9412: }
9413: /**
9414: * Push a new job onto a specific queue after (n) seconds.
9415: *
9416: * @param string $queue
9417: * @param \DateTimeInterface|\DateInterval|int $delay
9418: * @param string|object $job
9419: * @param mixed $data
9420: * @return mixed
9421: * @static
9422: */
9423: public static function laterOn($queue, $delay, $job, $data = '')
9424: {
9425: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9426: return $instance->laterOn($queue, $delay, $job, $data);
9427: }
9428: /**
9429: * Pop the next job off of the queue.
9430: *
9431: * @param string|null $queue
9432: * @return \Illuminate\Contracts\Queue\Job|null
9433: * @static
9434: */
9435: public static function pop($queue = null)
9436: {
9437: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9438: return $instance->pop($queue);
9439: }
9440: /**
9441: * Push an array of jobs onto the queue.
9442: *
9443: * @param array $jobs
9444: * @param mixed $data
9445: * @param string|null $queue
9446: * @return mixed
9447: * @static
9448: */
9449: public static function bulk($jobs, $data = '', $queue = null)
9450: {
9451: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9452: return $instance->bulk($jobs, $data, $queue);
9453: }
9454: /**
9455: * Get the jobs that have been pushed.
9456: *
9457: * @return array
9458: * @static
9459: */
9460: public static function pushedJobs()
9461: {
9462: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9463: return $instance->pushedJobs();
9464: }
9465: /**
9466: * Get the connection name for the queue.
9467: *
9468: * @return string
9469: * @static
9470: */
9471: public static function getConnectionName()
9472: {
9473: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9474: return $instance->getConnectionName();
9475: }
9476: /**
9477: * Set the connection name for the queue.
9478: *
9479: * @param string $name
9480: * @return \Illuminate\Support\Testing\Fakes\QueueFake
9481: * @static
9482: */
9483: public static function setConnectionName($name)
9484: {
9485: /** @var \Illuminate\Support\Testing\Fakes\QueueFake $instance */
9486: return $instance->setConnectionName($name);
9487: }
9488: /**
9489: * Release a reserved job back onto the queue after (n) seconds.
9490: *
9491: * @param string $queue
9492: * @param \Illuminate\Queue\Jobs\DatabaseJobRecord $job
9493: * @param int $delay
9494: * @return mixed
9495: * @static
9496: */
9497: public static function release($queue, $job, $delay)
9498: {
9499: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9500: return $instance->release($queue, $job, $delay);
9501: }
9502: /**
9503: * Delete a reserved job from the queue.
9504: *
9505: * @param string $queue
9506: * @param string $id
9507: * @return void
9508: * @throws \Throwable
9509: * @static
9510: */
9511: public static function deleteReserved($queue, $id)
9512: {
9513: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9514: $instance->deleteReserved($queue, $id);
9515: }
9516: /**
9517: * Delete a reserved job from the reserved queue and release it.
9518: *
9519: * @param string $queue
9520: * @param \Illuminate\Queue\Jobs\DatabaseJob $job
9521: * @param int $delay
9522: * @return void
9523: * @static
9524: */
9525: public static function deleteAndRelease($queue, $job, $delay)
9526: {
9527: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9528: $instance->deleteAndRelease($queue, $job, $delay);
9529: }
9530: /**
9531: * Delete all of the jobs from the queue.
9532: *
9533: * @param string $queue
9534: * @return int
9535: * @static
9536: */
9537: public static function clear($queue)
9538: {
9539: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9540: return $instance->clear($queue);
9541: }
9542: /**
9543: * Get the queue or return the default.
9544: *
9545: * @param string|null $queue
9546: * @return string
9547: * @static
9548: */
9549: public static function getQueue($queue)
9550: {
9551: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9552: return $instance->getQueue($queue);
9553: }
9554: /**
9555: * Get the underlying database instance.
9556: *
9557: * @return \Illuminate\Database\Connection
9558: * @static
9559: */
9560: public static function getDatabase()
9561: {
9562: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9563: return $instance->getDatabase();
9564: }
9565: /**
9566: * Get the backoff for an object-based queue handler.
9567: *
9568: * @param mixed $job
9569: * @return mixed
9570: * @static
9571: */
9572: public static function getJobBackoff($job)
9573: { //Method inherited from \Illuminate\Queue\Queue
9574: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9575: return $instance->getJobBackoff($job);
9576: }
9577: /**
9578: * Get the expiration timestamp for an object-based queue handler.
9579: *
9580: * @param mixed $job
9581: * @return mixed
9582: * @static
9583: */
9584: public static function getJobExpiration($job)
9585: { //Method inherited from \Illuminate\Queue\Queue
9586: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9587: return $instance->getJobExpiration($job);
9588: }
9589: /**
9590: * Register a callback to be executed when creating job payloads.
9591: *
9592: * @param callable|null $callback
9593: * @return void
9594: * @static
9595: */
9596: public static function createPayloadUsing($callback)
9597: { //Method inherited from \Illuminate\Queue\Queue
9598: \Illuminate\Queue\DatabaseQueue::createPayloadUsing($callback);
9599: }
9600: /**
9601: * Get the container instance being used by the connection.
9602: *
9603: * @return \Illuminate\Container\Container
9604: * @static
9605: */
9606: public static function getContainer()
9607: { //Method inherited from \Illuminate\Queue\Queue
9608: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9609: return $instance->getContainer();
9610: }
9611: /**
9612: * Set the IoC container instance.
9613: *
9614: * @param \Illuminate\Container\Container $container
9615: * @return void
9616: * @static
9617: */
9618: public static function setContainer($container)
9619: { //Method inherited from \Illuminate\Queue\Queue
9620: /** @var \Illuminate\Queue\DatabaseQueue $instance */
9621: $instance->setContainer($container);
9622: }
9623:
9624: }
9625: /**
9626: *
9627: *
9628: * @see \Illuminate\Cache\RateLimiter
9629: */
9630: class RateLimiter {
9631: /**
9632: * Register a named limiter configuration.
9633: *
9634: * @param string $name
9635: * @param \Closure $callback
9636: * @return \Illuminate\Cache\RateLimiter
9637: * @static
9638: */
9639: public static function for($name, $callback)
9640: {
9641: /** @var \Illuminate\Cache\RateLimiter $instance */
9642: return $instance->for($name, $callback);
9643: }
9644: /**
9645: * Get the given named rate limiter.
9646: *
9647: * @param string $name
9648: * @return \Closure
9649: * @static
9650: */
9651: public static function limiter($name)
9652: {
9653: /** @var \Illuminate\Cache\RateLimiter $instance */
9654: return $instance->limiter($name);
9655: }
9656: /**
9657: * Attempts to execute a callback if it's not limited.
9658: *
9659: * @param string $key
9660: * @param int $maxAttempts
9661: * @param \Closure $callback
9662: * @param int $decaySeconds
9663: * @return mixed
9664: * @static
9665: */
9666: public static function attempt($key, $maxAttempts, $callback, $decaySeconds = 60)
9667: {
9668: /** @var \Illuminate\Cache\RateLimiter $instance */
9669: return $instance->attempt($key, $maxAttempts, $callback, $decaySeconds);
9670: }
9671: /**
9672: * Determine if the given key has been "accessed" too many times.
9673: *
9674: * @param string $key
9675: * @param int $maxAttempts
9676: * @return bool
9677: * @static
9678: */
9679: public static function tooManyAttempts($key, $maxAttempts)
9680: {
9681: /** @var \Illuminate\Cache\RateLimiter $instance */
9682: return $instance->tooManyAttempts($key, $maxAttempts);
9683: }
9684: /**
9685: * Increment the counter for a given key for a given decay time.
9686: *
9687: * @param string $key
9688: * @param int $decaySeconds
9689: * @return int
9690: * @static
9691: */
9692: public static function hit($key, $decaySeconds = 60)
9693: {
9694: /** @var \Illuminate\Cache\RateLimiter $instance */
9695: return $instance->hit($key, $decaySeconds);
9696: }
9697: /**
9698: * Get the number of attempts for the given key.
9699: *
9700: * @param string $key
9701: * @return mixed
9702: * @static
9703: */
9704: public static function attempts($key)
9705: {
9706: /** @var \Illuminate\Cache\RateLimiter $instance */
9707: return $instance->attempts($key);
9708: }
9709: /**
9710: * Reset the number of attempts for the given key.
9711: *
9712: * @param string $key
9713: * @return mixed
9714: * @static
9715: */
9716: public static function resetAttempts($key)
9717: {
9718: /** @var \Illuminate\Cache\RateLimiter $instance */
9719: return $instance->resetAttempts($key);
9720: }
9721: /**
9722: * Get the number of retries left for the given key.
9723: *
9724: * @param string $key
9725: * @param int $maxAttempts
9726: * @return int
9727: * @static
9728: */
9729: public static function remaining($key, $maxAttempts)
9730: {
9731: /** @var \Illuminate\Cache\RateLimiter $instance */
9732: return $instance->remaining($key, $maxAttempts);
9733: }
9734: /**
9735: * Get the number of retries left for the given key.
9736: *
9737: * @param string $key
9738: * @param int $maxAttempts
9739: * @return int
9740: * @static
9741: */
9742: public static function retriesLeft($key, $maxAttempts)
9743: {
9744: /** @var \Illuminate\Cache\RateLimiter $instance */
9745: return $instance->retriesLeft($key, $maxAttempts);
9746: }
9747: /**
9748: * Clear the hits and lockout timer for the given key.
9749: *
9750: * @param string $key
9751: * @return void
9752: * @static
9753: */
9754: public static function clear($key)
9755: {
9756: /** @var \Illuminate\Cache\RateLimiter $instance */
9757: $instance->clear($key);
9758: }
9759: /**
9760: * Get the number of seconds until the "key" is accessible again.
9761: *
9762: * @param string $key
9763: * @return int
9764: * @static
9765: */
9766: public static function availableIn($key)
9767: {
9768: /** @var \Illuminate\Cache\RateLimiter $instance */
9769: return $instance->availableIn($key);
9770: }
9771: /**
9772: * Clean the rate limiter key from unicode characters.
9773: *
9774: * @param string $key
9775: * @return string
9776: * @static
9777: */
9778: public static function cleanRateLimiterKey($key)
9779: {
9780: /** @var \Illuminate\Cache\RateLimiter $instance */
9781: return $instance->cleanRateLimiterKey($key);
9782: }
9783:
9784: }
9785: /**
9786: *
9787: *
9788: * @see \Illuminate\Routing\Redirector
9789: */
9790: class Redirect {
9791: /**
9792: * Create a new redirect response to the "home" route.
9793: *
9794: * @param int $status
9795: * @return \Illuminate\Http\RedirectResponse
9796: * @deprecated Will be removed in a future Laravel version.
9797: * @static
9798: */
9799: public static function home($status = 302)
9800: {
9801: /** @var \Illuminate\Routing\Redirector $instance */
9802: return $instance->home($status);
9803: }
9804: /**
9805: * Create a new redirect response to the previous location.
9806: *
9807: * @param int $status
9808: * @param array $headers
9809: * @param mixed $fallback
9810: * @return \Illuminate\Http\RedirectResponse
9811: * @static
9812: */
9813: public static function back($status = 302, $headers = [], $fallback = false)
9814: {
9815: /** @var \Illuminate\Routing\Redirector $instance */
9816: return $instance->back($status, $headers, $fallback);
9817: }
9818: /**
9819: * Create a new redirect response to the current URI.
9820: *
9821: * @param int $status
9822: * @param array $headers
9823: * @return \Illuminate\Http\RedirectResponse
9824: * @static
9825: */
9826: public static function refresh($status = 302, $headers = [])
9827: {
9828: /** @var \Illuminate\Routing\Redirector $instance */
9829: return $instance->refresh($status, $headers);
9830: }
9831: /**
9832: * Create a new redirect response, while putting the current URL in the session.
9833: *
9834: * @param string $path
9835: * @param int $status
9836: * @param array $headers
9837: * @param bool|null $secure
9838: * @return \Illuminate\Http\RedirectResponse
9839: * @static
9840: */
9841: public static function guest($path, $status = 302, $headers = [], $secure = null)
9842: {
9843: /** @var \Illuminate\Routing\Redirector $instance */
9844: return $instance->guest($path, $status, $headers, $secure);
9845: }
9846: /**
9847: * Create a new redirect response to the previously intended location.
9848: *
9849: * @param mixed $default
9850: * @param int $status
9851: * @param array $headers
9852: * @param bool|null $secure
9853: * @return \Illuminate\Http\RedirectResponse
9854: * @static
9855: */
9856: public static function intended($default = '/', $status = 302, $headers = [], $secure = null)
9857: {
9858: /** @var \Illuminate\Routing\Redirector $instance */
9859: return $instance->intended($default, $status, $headers, $secure);
9860: }
9861: /**
9862: * Set the intended url.
9863: *
9864: * @param string $url
9865: * @return \Illuminate\Routing\Redirector
9866: * @static
9867: */
9868: public static function setIntendedUrl($url)
9869: {
9870: /** @var \Illuminate\Routing\Redirector $instance */
9871: return $instance->setIntendedUrl($url);
9872: }
9873: /**
9874: * Create a new redirect response to the given path.
9875: *
9876: * @param string $path
9877: * @param int $status
9878: * @param array $headers
9879: * @param bool|null $secure
9880: * @return \Illuminate\Http\RedirectResponse
9881: * @static
9882: */
9883: public static function to($path, $status = 302, $headers = [], $secure = null)
9884: {
9885: /** @var \Illuminate\Routing\Redirector $instance */
9886: return $instance->to($path, $status, $headers, $secure);
9887: }
9888: /**
9889: * Create a new redirect response to an external URL (no validation).
9890: *
9891: * @param string $path
9892: * @param int $status
9893: * @param array $headers
9894: * @return \Illuminate\Http\RedirectResponse
9895: * @static
9896: */
9897: public static function away($path, $status = 302, $headers = [])
9898: {
9899: /** @var \Illuminate\Routing\Redirector $instance */
9900: return $instance->away($path, $status, $headers);
9901: }
9902: /**
9903: * Create a new redirect response to the given HTTPS path.
9904: *
9905: * @param string $path
9906: * @param int $status
9907: * @param array $headers
9908: * @return \Illuminate\Http\RedirectResponse
9909: * @static
9910: */
9911: public static function secure($path, $status = 302, $headers = [])
9912: {
9913: /** @var \Illuminate\Routing\Redirector $instance */
9914: return $instance->secure($path, $status, $headers);
9915: }
9916: /**
9917: * Create a new redirect response to a named route.
9918: *
9919: * @param string $route
9920: * @param mixed $parameters
9921: * @param int $status
9922: * @param array $headers
9923: * @return \Illuminate\Http\RedirectResponse
9924: * @static
9925: */
9926: public static function route($route, $parameters = [], $status = 302, $headers = [])
9927: {
9928: /** @var \Illuminate\Routing\Redirector $instance */
9929: return $instance->route($route, $parameters, $status, $headers);
9930: }
9931: /**
9932: * Create a new redirect response to a signed named route.
9933: *
9934: * @param string $route
9935: * @param mixed $parameters
9936: * @param \DateTimeInterface|\DateInterval|int|null $expiration
9937: * @param int $status
9938: * @param array $headers
9939: * @return \Illuminate\Http\RedirectResponse
9940: * @static
9941: */
9942: public static function signedRoute($route, $parameters = [], $expiration = null, $status = 302, $headers = [])
9943: {
9944: /** @var \Illuminate\Routing\Redirector $instance */
9945: return $instance->signedRoute($route, $parameters, $expiration, $status, $headers);
9946: }
9947: /**
9948: * Create a new redirect response to a signed named route.
9949: *
9950: * @param string $route
9951: * @param \DateTimeInterface|\DateInterval|int|null $expiration
9952: * @param mixed $parameters
9953: * @param int $status
9954: * @param array $headers
9955: * @return \Illuminate\Http\RedirectResponse
9956: * @static
9957: */
9958: public static function temporarySignedRoute($route, $expiration, $parameters = [], $status = 302, $headers = [])
9959: {
9960: /** @var \Illuminate\Routing\Redirector $instance */
9961: return $instance->temporarySignedRoute($route, $expiration, $parameters, $status, $headers);
9962: }
9963: /**
9964: * Create a new redirect response to a controller action.
9965: *
9966: * @param string|array $action
9967: * @param mixed $parameters
9968: * @param int $status
9969: * @param array $headers
9970: * @return \Illuminate\Http\RedirectResponse
9971: * @static
9972: */
9973: public static function action($action, $parameters = [], $status = 302, $headers = [])
9974: {
9975: /** @var \Illuminate\Routing\Redirector $instance */
9976: return $instance->action($action, $parameters, $status, $headers);
9977: }
9978: /**
9979: * Get the URL generator instance.
9980: *
9981: * @return \Illuminate\Routing\UrlGenerator
9982: * @static
9983: */
9984: public static function getUrlGenerator()
9985: {
9986: /** @var \Illuminate\Routing\Redirector $instance */
9987: return $instance->getUrlGenerator();
9988: }
9989: /**
9990: * Set the active session store.
9991: *
9992: * @param \Illuminate\Session\Store $session
9993: * @return void
9994: * @static
9995: */
9996: public static function setSession($session)
9997: {
9998: /** @var \Illuminate\Routing\Redirector $instance */
9999: $instance->setSession($session);
10000: }
10001: /**
10002: * Register a custom macro.
10003: *
10004: * @param string $name
10005: * @param object|callable $macro
10006: * @return void
10007: * @static
10008: */
10009: public static function macro($name, $macro)
10010: {
10011: \Illuminate\Routing\Redirector::macro($name, $macro);
10012: }
10013: /**
10014: * Mix another object into the class.
10015: *
10016: * @param object $mixin
10017: * @param bool $replace
10018: * @return void
10019: * @throws \ReflectionException
10020: * @static
10021: */
10022: public static function mixin($mixin, $replace = true)
10023: {
10024: \Illuminate\Routing\Redirector::mixin($mixin, $replace);
10025: }
10026: /**
10027: * Checks if macro is registered.
10028: *
10029: * @param string $name
10030: * @return bool
10031: * @static
10032: */
10033: public static function hasMacro($name)
10034: {
10035: return \Illuminate\Routing\Redirector::hasMacro($name);
10036: }
10037: /**
10038: * Flush the existing macros.
10039: *
10040: * @return void
10041: * @static
10042: */
10043: public static function flushMacros()
10044: {
10045: \Illuminate\Routing\Redirector::flushMacros();
10046: }
10047:
10048: }
10049: /**
10050: *
10051: *
10052: * @method static mixed filterFiles(mixed $files)
10053: * @see \Illuminate\Http\Request
10054: */
10055: class Request {
10056: /**
10057: * Create a new Illuminate HTTP request from server variables.
10058: *
10059: * @return static
10060: * @static
10061: */
10062: public static function capture()
10063: {
10064: return \Illuminate\Http\Request::capture();
10065: }
10066: /**
10067: * Return the Request instance.
10068: *
10069: * @return \Illuminate\Http\Request
10070: * @static
10071: */
10072: public static function instance()
10073: {
10074: /** @var \Illuminate\Http\Request $instance */
10075: return $instance->instance();
10076: }
10077: /**
10078: * Get the request method.
10079: *
10080: * @return string
10081: * @static
10082: */
10083: public static function method()
10084: {
10085: /** @var \Illuminate\Http\Request $instance */
10086: return $instance->method();
10087: }
10088: /**
10089: * Get the root URL for the application.
10090: *
10091: * @return string
10092: * @static
10093: */
10094: public static function root()
10095: {
10096: /** @var \Illuminate\Http\Request $instance */
10097: return $instance->root();
10098: }
10099: /**
10100: * Get the URL (no query string) for the request.
10101: *
10102: * @return string
10103: * @static
10104: */
10105: public static function url()
10106: {
10107: /** @var \Illuminate\Http\Request $instance */
10108: return $instance->url();
10109: }
10110: /**
10111: * Get the full URL for the request.
10112: *
10113: * @return string
10114: * @static
10115: */
10116: public static function fullUrl()
10117: {
10118: /** @var \Illuminate\Http\Request $instance */
10119: return $instance->fullUrl();
10120: }
10121: /**
10122: * Get the full URL for the request with the added query string parameters.
10123: *
10124: * @param array $query
10125: * @return string
10126: * @static
10127: */
10128: public static function fullUrlWithQuery($query)
10129: {
10130: /** @var \Illuminate\Http\Request $instance */
10131: return $instance->fullUrlWithQuery($query);
10132: }
10133: /**
10134: * Get the full URL for the request without the given query string parameters.
10135: *
10136: * @param array|string $keys
10137: * @return string
10138: * @static
10139: */
10140: public static function fullUrlWithoutQuery($keys)
10141: {
10142: /** @var \Illuminate\Http\Request $instance */
10143: return $instance->fullUrlWithoutQuery($keys);
10144: }
10145: /**
10146: * Get the current path info for the request.
10147: *
10148: * @return string
10149: * @static
10150: */
10151: public static function path()
10152: {
10153: /** @var \Illuminate\Http\Request $instance */
10154: return $instance->path();
10155: }
10156: /**
10157: * Get the current decoded path info for the request.
10158: *
10159: * @return string
10160: * @static
10161: */
10162: public static function decodedPath()
10163: {
10164: /** @var \Illuminate\Http\Request $instance */
10165: return $instance->decodedPath();
10166: }
10167: /**
10168: * Get a segment from the URI (1 based index).
10169: *
10170: * @param int $index
10171: * @param string|null $default
10172: * @return string|null
10173: * @static
10174: */
10175: public static function segment($index, $default = null)
10176: {
10177: /** @var \Illuminate\Http\Request $instance */
10178: return $instance->segment($index, $default);
10179: }
10180: /**
10181: * Get all of the segments for the request path.
10182: *
10183: * @return array
10184: * @static
10185: */
10186: public static function segments()
10187: {
10188: /** @var \Illuminate\Http\Request $instance */
10189: return $instance->segments();
10190: }
10191: /**
10192: * Determine if the current request URI matches a pattern.
10193: *
10194: * @param mixed $patterns
10195: * @return bool
10196: * @static
10197: */
10198: public static function is(...$patterns)
10199: {
10200: /** @var \Illuminate\Http\Request $instance */
10201: return $instance->is(...$patterns);
10202: }
10203: /**
10204: * Determine if the route name matches a given pattern.
10205: *
10206: * @param mixed $patterns
10207: * @return bool
10208: * @static
10209: */
10210: public static function routeIs(...$patterns)
10211: {
10212: /** @var \Illuminate\Http\Request $instance */
10213: return $instance->routeIs(...$patterns);
10214: }
10215: /**
10216: * Determine if the current request URL and query string match a pattern.
10217: *
10218: * @param mixed $patterns
10219: * @return bool
10220: * @static
10221: */
10222: public static function fullUrlIs(...$patterns)
10223: {
10224: /** @var \Illuminate\Http\Request $instance */
10225: return $instance->fullUrlIs(...$patterns);
10226: }
10227: /**
10228: * Get the host name.
10229: *
10230: * @return string
10231: * @static
10232: */
10233: public static function host()
10234: {
10235: /** @var \Illuminate\Http\Request $instance */
10236: return $instance->host();
10237: }
10238: /**
10239: * Get the HTTP host being requested.
10240: *
10241: * @return string
10242: * @static
10243: */
10244: public static function httpHost()
10245: {
10246: /** @var \Illuminate\Http\Request $instance */
10247: return $instance->httpHost();
10248: }
10249: /**
10250: * Get the scheme and HTTP host.
10251: *
10252: * @return string
10253: * @static
10254: */
10255: public static function schemeAndHttpHost()
10256: {
10257: /** @var \Illuminate\Http\Request $instance */
10258: return $instance->schemeAndHttpHost();
10259: }
10260: /**
10261: * Determine if the request is the result of an AJAX call.
10262: *
10263: * @return bool
10264: * @static
10265: */
10266: public static function ajax()
10267: {
10268: /** @var \Illuminate\Http\Request $instance */
10269: return $instance->ajax();
10270: }
10271: /**
10272: * Determine if the request is the result of a PJAX call.
10273: *
10274: * @return bool
10275: * @static
10276: */
10277: public static function pjax()
10278: {
10279: /** @var \Illuminate\Http\Request $instance */
10280: return $instance->pjax();
10281: }
10282: /**
10283: * Determine if the request is the result of a prefetch call.
10284: *
10285: * @return bool
10286: * @static
10287: */
10288: public static function prefetch()
10289: {
10290: /** @var \Illuminate\Http\Request $instance */
10291: return $instance->prefetch();
10292: }
10293: /**
10294: * Determine if the request is over HTTPS.
10295: *
10296: * @return bool
10297: * @static
10298: */
10299: public static function secure()
10300: {
10301: /** @var \Illuminate\Http\Request $instance */
10302: return $instance->secure();
10303: }
10304: /**
10305: * Get the client IP address.
10306: *
10307: * @return string|null
10308: * @static
10309: */
10310: public static function ip()
10311: {
10312: /** @var \Illuminate\Http\Request $instance */
10313: return $instance->ip();
10314: }
10315: /**
10316: * Get the client IP addresses.
10317: *
10318: * @return array
10319: * @static
10320: */
10321: public static function ips()
10322: {
10323: /** @var \Illuminate\Http\Request $instance */
10324: return $instance->ips();
10325: }
10326: /**
10327: * Get the client user agent.
10328: *
10329: * @return string|null
10330: * @static
10331: */
10332: public static function userAgent()
10333: {
10334: /** @var \Illuminate\Http\Request $instance */
10335: return $instance->userAgent();
10336: }
10337: /**
10338: * Merge new input into the current request's input array.
10339: *
10340: * @param array $input
10341: * @return \Illuminate\Http\Request
10342: * @static
10343: */
10344: public static function merge($input)
10345: {
10346: /** @var \Illuminate\Http\Request $instance */
10347: return $instance->merge($input);
10348: }
10349: /**
10350: * Merge new input into the request's input, but only when that key is missing from the request.
10351: *
10352: * @param array $input
10353: * @return \Illuminate\Http\Request
10354: * @static
10355: */
10356: public static function mergeIfMissing($input)
10357: {
10358: /** @var \Illuminate\Http\Request $instance */
10359: return $instance->mergeIfMissing($input);
10360: }
10361: /**
10362: * Replace the input for the current request.
10363: *
10364: * @param array $input
10365: * @return \Illuminate\Http\Request
10366: * @static
10367: */
10368: public static function replace($input)
10369: {
10370: /** @var \Illuminate\Http\Request $instance */
10371: return $instance->replace($input);
10372: }
10373: /**
10374: * This method belongs to Symfony HttpFoundation and is not usually needed when using Laravel.
10375: *
10376: * Instead, you may use the "input" method.
10377: *
10378: * @param string $key
10379: * @param mixed $default
10380: * @return mixed
10381: * @static
10382: */
10383: public static function get($key, $default = null)
10384: {
10385: /** @var \Illuminate\Http\Request $instance */
10386: return $instance->get($key, $default);
10387: }
10388: /**
10389: * Get the JSON payload for the request.
10390: *
10391: * @param string|null $key
10392: * @param mixed $default
10393: * @return \Symfony\Component\HttpFoundation\ParameterBag|mixed
10394: * @static
10395: */
10396: public static function json($key = null, $default = null)
10397: {
10398: /** @var \Illuminate\Http\Request $instance */
10399: return $instance->json($key, $default);
10400: }
10401: /**
10402: * Create a new request instance from the given Laravel request.
10403: *
10404: * @param \Illuminate\Http\Request $from
10405: * @param \Illuminate\Http\Request|null $to
10406: * @return static
10407: * @static
10408: */
10409: public static function createFrom($from, $to = null)
10410: {
10411: return \Illuminate\Http\Request::createFrom($from, $to);
10412: }
10413: /**
10414: * Create an Illuminate request from a Symfony instance.
10415: *
10416: * @param \Symfony\Component\HttpFoundation\Request $request
10417: * @return static
10418: * @static
10419: */
10420: public static function createFromBase($request)
10421: {
10422: return \Illuminate\Http\Request::createFromBase($request);
10423: }
10424: /**
10425: * Clones a request and overrides some of its parameters.
10426: *
10427: * @return static
10428: * @param array $query The GET parameters
10429: * @param array $request The POST parameters
10430: * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
10431: * @param array $cookies The COOKIE parameters
10432: * @param array $files The FILES parameters
10433: * @param array $server The SERVER parameters
10434: * @static
10435: */
10436: public static function duplicate($query = null, $request = null, $attributes = null, $cookies = null, $files = null, $server = null)
10437: {
10438: /** @var \Illuminate\Http\Request $instance */
10439: return $instance->duplicate($query, $request, $attributes, $cookies, $files, $server);
10440: }
10441: /**
10442: * Whether the request contains a Session object.
10443: *
10444: * This method does not give any information about the state of the session object,
10445: * like whether the session is started or not. It is just a way to check if this Request
10446: * is associated with a Session instance.
10447: *
10448: * @param bool $skipIfUninitialized When true, ignores factories injected by `setSessionFactory`
10449: * @static
10450: */
10451: public static function hasSession($skipIfUninitialized = false)
10452: {
10453: /** @var \Illuminate\Http\Request $instance */
10454: return $instance->hasSession($skipIfUninitialized);
10455: }
10456: /**
10457: * Gets the Session.
10458: *
10459: * @throws SessionNotFoundException When session is not set properly
10460: * @static
10461: */
10462: public static function getSession()
10463: {
10464: /** @var \Illuminate\Http\Request $instance */
10465: return $instance->getSession();
10466: }
10467: /**
10468: * Get the session associated with the request.
10469: *
10470: * @return \Illuminate\Contracts\Session\Session
10471: * @throws \RuntimeException
10472: * @static
10473: */
10474: public static function session()
10475: {
10476: /** @var \Illuminate\Http\Request $instance */
10477: return $instance->session();
10478: }
10479: /**
10480: * Set the session instance on the request.
10481: *
10482: * @param \Illuminate\Contracts\Session\Session $session
10483: * @return void
10484: * @static
10485: */
10486: public static function setLaravelSession($session)
10487: {
10488: /** @var \Illuminate\Http\Request $instance */
10489: $instance->setLaravelSession($session);
10490: }
10491: /**
10492: * Get the user making the request.
10493: *
10494: * @param string|null $guard
10495: * @return mixed
10496: * @static
10497: */
10498: public static function user($guard = null)
10499: {
10500: /** @var \Illuminate\Http\Request $instance */
10501: return $instance->user($guard);
10502: }
10503: /**
10504: * Get the route handling the request.
10505: *
10506: * @param string|null $param
10507: * @param mixed $default
10508: * @return \Illuminate\Routing\Route|object|string|null
10509: * @static
10510: */
10511: public static function route($param = null, $default = null)
10512: {
10513: /** @var \Illuminate\Http\Request $instance */
10514: return $instance->route($param, $default);
10515: }
10516: /**
10517: * Get a unique fingerprint for the request / route / IP address.
10518: *
10519: * @return string
10520: * @throws \RuntimeException
10521: * @static
10522: */
10523: public static function fingerprint()
10524: {
10525: /** @var \Illuminate\Http\Request $instance */
10526: return $instance->fingerprint();
10527: }
10528: /**
10529: * Set the JSON payload for the request.
10530: *
10531: * @param \Symfony\Component\HttpFoundation\ParameterBag $json
10532: * @return \Illuminate\Http\Request
10533: * @static
10534: */
10535: public static function setJson($json)
10536: {
10537: /** @var \Illuminate\Http\Request $instance */
10538: return $instance->setJson($json);
10539: }
10540: /**
10541: * Get the user resolver callback.
10542: *
10543: * @return \Closure
10544: * @static
10545: */
10546: public static function getUserResolver()
10547: {
10548: /** @var \Illuminate\Http\Request $instance */
10549: return $instance->getUserResolver();
10550: }
10551: /**
10552: * Set the user resolver callback.
10553: *
10554: * @param \Closure $callback
10555: * @return \Illuminate\Http\Request
10556: * @static
10557: */
10558: public static function setUserResolver($callback)
10559: {
10560: /** @var \Illuminate\Http\Request $instance */
10561: return $instance->setUserResolver($callback);
10562: }
10563: /**
10564: * Get the route resolver callback.
10565: *
10566: * @return \Closure
10567: * @static
10568: */
10569: public static function getRouteResolver()
10570: {
10571: /** @var \Illuminate\Http\Request $instance */
10572: return $instance->getRouteResolver();
10573: }
10574: /**
10575: * Set the route resolver callback.
10576: *
10577: * @param \Closure $callback
10578: * @return \Illuminate\Http\Request
10579: * @static
10580: */
10581: public static function setRouteResolver($callback)
10582: {
10583: /** @var \Illuminate\Http\Request $instance */
10584: return $instance->setRouteResolver($callback);
10585: }
10586: /**
10587: * Get all of the input and files for the request.
10588: *
10589: * @return array
10590: * @static
10591: */
10592: public static function toArray()
10593: {
10594: /** @var \Illuminate\Http\Request $instance */
10595: return $instance->toArray();
10596: }
10597: /**
10598: * Determine if the given offset exists.
10599: *
10600: * @param string $offset
10601: * @return bool
10602: * @static
10603: */
10604: public static function offsetExists($offset)
10605: {
10606: /** @var \Illuminate\Http\Request $instance */
10607: return $instance->offsetExists($offset);
10608: }
10609: /**
10610: * Get the value at the given offset.
10611: *
10612: * @param string $offset
10613: * @return mixed
10614: * @static
10615: */
10616: public static function offsetGet($offset)
10617: {
10618: /** @var \Illuminate\Http\Request $instance */
10619: return $instance->offsetGet($offset);
10620: }
10621: /**
10622: * Set the value at the given offset.
10623: *
10624: * @param string $offset
10625: * @param mixed $value
10626: * @return void
10627: * @static
10628: */
10629: public static function offsetSet($offset, $value)
10630: {
10631: /** @var \Illuminate\Http\Request $instance */
10632: $instance->offsetSet($offset, $value);
10633: }
10634: /**
10635: * Remove the value at the given offset.
10636: *
10637: * @param string $offset
10638: * @return void
10639: * @static
10640: */
10641: public static function offsetUnset($offset)
10642: {
10643: /** @var \Illuminate\Http\Request $instance */
10644: $instance->offsetUnset($offset);
10645: }
10646: /**
10647: * Sets the parameters for this request.
10648: *
10649: * This method also re-initializes all properties.
10650: *
10651: * @param array $query The GET parameters
10652: * @param array $request The POST parameters
10653: * @param array $attributes The request attributes (parameters parsed from the PATH_INFO, ...)
10654: * @param array $cookies The COOKIE parameters
10655: * @param array $files The FILES parameters
10656: * @param array $server The SERVER parameters
10657: * @param string|resource|null $content The raw body data
10658: * @static
10659: */
10660: public static function initialize($query = [], $request = [], $attributes = [], $cookies = [], $files = [], $server = [], $content = null)
10661: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10662: /** @var \Illuminate\Http\Request $instance */
10663: return $instance->initialize($query, $request, $attributes, $cookies, $files, $server, $content);
10664: }
10665: /**
10666: * Creates a new request with values from PHP's super globals.
10667: *
10668: * @static
10669: */
10670: public static function createFromGlobals()
10671: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10672: return \Illuminate\Http\Request::createFromGlobals();
10673: }
10674: /**
10675: * Creates a Request based on a given URI and configuration.
10676: *
10677: * The information contained in the URI always take precedence
10678: * over the other information (server and parameters).
10679: *
10680: * @param string $uri The URI
10681: * @param string $method The HTTP method
10682: * @param array $parameters The query (GET) or request (POST) parameters
10683: * @param array $cookies The request cookies ($_COOKIE)
10684: * @param array $files The request files ($_FILES)
10685: * @param array $server The server parameters ($_SERVER)
10686: * @param string|resource|null $content The raw body data
10687: * @static
10688: */
10689: public static function create($uri, $method = 'GET', $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
10690: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10691: return \Illuminate\Http\Request::create($uri, $method, $parameters, $cookies, $files, $server, $content);
10692: }
10693: /**
10694: * Sets a callable able to create a Request instance.
10695: *
10696: * This is mainly useful when you need to override the Request class
10697: * to keep BC with an existing system. It should not be used for any
10698: * other purpose.
10699: *
10700: * @static
10701: */
10702: public static function setFactory($callable)
10703: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10704: return \Illuminate\Http\Request::setFactory($callable);
10705: }
10706: /**
10707: * Overrides the PHP global variables according to this request instance.
10708: *
10709: * It overrides $_GET, $_POST, $_REQUEST, $_SERVER, $_COOKIE.
10710: * $_FILES is never overridden, see rfc1867
10711: *
10712: * @static
10713: */
10714: public static function overrideGlobals()
10715: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10716: /** @var \Illuminate\Http\Request $instance */
10717: return $instance->overrideGlobals();
10718: }
10719: /**
10720: * Sets a list of trusted proxies.
10721: *
10722: * You should only list the reverse proxies that you manage directly.
10723: *
10724: * @param array $proxies A list of trusted proxies, the string 'REMOTE_ADDR' will be replaced with $_SERVER['REMOTE_ADDR']
10725: * @param int $trustedHeaderSet A bit field of Request::HEADER_*, to set which headers to trust from your proxies
10726: * @static
10727: */
10728: public static function setTrustedProxies($proxies, $trustedHeaderSet)
10729: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10730: return \Illuminate\Http\Request::setTrustedProxies($proxies, $trustedHeaderSet);
10731: }
10732: /**
10733: * Gets the list of trusted proxies.
10734: *
10735: * @static
10736: */
10737: public static function getTrustedProxies()
10738: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10739: return \Illuminate\Http\Request::getTrustedProxies();
10740: }
10741: /**
10742: * Gets the set of trusted headers from trusted proxies.
10743: *
10744: * @return int A bit field of Request::HEADER_* that defines which headers are trusted from your proxies
10745: * @static
10746: */
10747: public static function getTrustedHeaderSet()
10748: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10749: return \Illuminate\Http\Request::getTrustedHeaderSet();
10750: }
10751: /**
10752: * Sets a list of trusted host patterns.
10753: *
10754: * You should only list the hosts you manage using regexs.
10755: *
10756: * @param array $hostPatterns A list of trusted host patterns
10757: * @static
10758: */
10759: public static function setTrustedHosts($hostPatterns)
10760: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10761: return \Illuminate\Http\Request::setTrustedHosts($hostPatterns);
10762: }
10763: /**
10764: * Gets the list of trusted host patterns.
10765: *
10766: * @static
10767: */
10768: public static function getTrustedHosts()
10769: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10770: return \Illuminate\Http\Request::getTrustedHosts();
10771: }
10772: /**
10773: * Normalizes a query string.
10774: *
10775: * It builds a normalized query string, where keys/value pairs are alphabetized,
10776: * have consistent escaping and unneeded delimiters are removed.
10777: *
10778: * @static
10779: */
10780: public static function normalizeQueryString($qs)
10781: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10782: return \Illuminate\Http\Request::normalizeQueryString($qs);
10783: }
10784: /**
10785: * Enables support for the _method request parameter to determine the intended HTTP method.
10786: *
10787: * Be warned that enabling this feature might lead to CSRF issues in your code.
10788: * Check that you are using CSRF tokens when required.
10789: * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
10790: * and used to send a "PUT" or "DELETE" request via the _method request parameter.
10791: * If these methods are not protected against CSRF, this presents a possible vulnerability.
10792: *
10793: * The HTTP method can only be overridden when the real HTTP method is POST.
10794: *
10795: * @static
10796: */
10797: public static function enableHttpMethodParameterOverride()
10798: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10799: return \Illuminate\Http\Request::enableHttpMethodParameterOverride();
10800: }
10801: /**
10802: * Checks whether support for the _method request parameter is enabled.
10803: *
10804: * @static
10805: */
10806: public static function getHttpMethodParameterOverride()
10807: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10808: return \Illuminate\Http\Request::getHttpMethodParameterOverride();
10809: }
10810: /**
10811: * Whether the request contains a Session which was started in one of the
10812: * previous requests.
10813: *
10814: * @static
10815: */
10816: public static function hasPreviousSession()
10817: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10818: /** @var \Illuminate\Http\Request $instance */
10819: return $instance->hasPreviousSession();
10820: }
10821: /**
10822: *
10823: *
10824: * @static
10825: */
10826: public static function setSession($session)
10827: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10828: /** @var \Illuminate\Http\Request $instance */
10829: return $instance->setSession($session);
10830: }
10831: /**
10832: *
10833: *
10834: * @internal
10835: * @param \Symfony\Component\HttpFoundation\callable(): SessionInterface $factory
10836: * @static
10837: */
10838: public static function setSessionFactory($factory)
10839: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10840: /** @var \Illuminate\Http\Request $instance */
10841: return $instance->setSessionFactory($factory);
10842: }
10843: /**
10844: * Returns the client IP addresses.
10845: *
10846: * In the returned array the most trusted IP address is first, and the
10847: * least trusted one last. The "real" client IP address is the last one,
10848: * but this is also the least trusted one. Trusted proxies are stripped.
10849: *
10850: * Use this method carefully; you should use getClientIp() instead.
10851: *
10852: * @see getClientIp()
10853: * @static
10854: */
10855: public static function getClientIps()
10856: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10857: /** @var \Illuminate\Http\Request $instance */
10858: return $instance->getClientIps();
10859: }
10860: /**
10861: * Returns the client IP address.
10862: *
10863: * This method can read the client IP address from the "X-Forwarded-For" header
10864: * when trusted proxies were set via "setTrustedProxies()". The "X-Forwarded-For"
10865: * header value is a comma+space separated list of IP addresses, the left-most
10866: * being the original client, and each successive proxy that passed the request
10867: * adding the IP address where it received the request from.
10868: *
10869: * If your reverse proxy uses a different header name than "X-Forwarded-For",
10870: * ("Client-Ip" for instance), configure it via the $trustedHeaderSet
10871: * argument of the Request::setTrustedProxies() method instead.
10872: *
10873: * @see getClientIps()
10874: * @see https://wikipedia.org/wiki/X-Forwarded-For
10875: * @static
10876: */
10877: public static function getClientIp()
10878: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10879: /** @var \Illuminate\Http\Request $instance */
10880: return $instance->getClientIp();
10881: }
10882: /**
10883: * Returns current script name.
10884: *
10885: * @static
10886: */
10887: public static function getScriptName()
10888: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10889: /** @var \Illuminate\Http\Request $instance */
10890: return $instance->getScriptName();
10891: }
10892: /**
10893: * Returns the path being requested relative to the executed script.
10894: *
10895: * The path info always starts with a /.
10896: *
10897: * Suppose this request is instantiated from /mysite on localhost:
10898: *
10899: * * http://localhost/mysite returns an empty string
10900: * * http://localhost/mysite/about returns '/about'
10901: * * http://localhost/mysite/enco%20ded returns '/enco%20ded'
10902: * * http://localhost/mysite/about?var=1 returns '/about'
10903: *
10904: * @return string The raw path (i.e. not urldecoded)
10905: * @static
10906: */
10907: public static function getPathInfo()
10908: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10909: /** @var \Illuminate\Http\Request $instance */
10910: return $instance->getPathInfo();
10911: }
10912: /**
10913: * Returns the root path from which this request is executed.
10914: *
10915: * Suppose that an index.php file instantiates this request object:
10916: *
10917: * * http://localhost/index.php returns an empty string
10918: * * http://localhost/index.php/page returns an empty string
10919: * * http://localhost/web/index.php returns '/web'
10920: * * http://localhost/we%20b/index.php returns '/we%20b'
10921: *
10922: * @return string The raw path (i.e. not urldecoded)
10923: * @static
10924: */
10925: public static function getBasePath()
10926: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10927: /** @var \Illuminate\Http\Request $instance */
10928: return $instance->getBasePath();
10929: }
10930: /**
10931: * Returns the root URL from which this request is executed.
10932: *
10933: * The base URL never ends with a /.
10934: *
10935: * This is similar to getBasePath(), except that it also includes the
10936: * script filename (e.g. index.php) if one exists.
10937: *
10938: * @return string The raw URL (i.e. not urldecoded)
10939: * @static
10940: */
10941: public static function getBaseUrl()
10942: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10943: /** @var \Illuminate\Http\Request $instance */
10944: return $instance->getBaseUrl();
10945: }
10946: /**
10947: * Gets the request's scheme.
10948: *
10949: * @static
10950: */
10951: public static function getScheme()
10952: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10953: /** @var \Illuminate\Http\Request $instance */
10954: return $instance->getScheme();
10955: }
10956: /**
10957: * Returns the port on which the request is made.
10958: *
10959: * This method can read the client port from the "X-Forwarded-Port" header
10960: * when trusted proxies were set via "setTrustedProxies()".
10961: *
10962: * The "X-Forwarded-Port" header must contain the client port.
10963: *
10964: * @return int|string|null Can be a string if fetched from the server bag
10965: * @static
10966: */
10967: public static function getPort()
10968: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10969: /** @var \Illuminate\Http\Request $instance */
10970: return $instance->getPort();
10971: }
10972: /**
10973: * Returns the user.
10974: *
10975: * @static
10976: */
10977: public static function getUser()
10978: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10979: /** @var \Illuminate\Http\Request $instance */
10980: return $instance->getUser();
10981: }
10982: /**
10983: * Returns the password.
10984: *
10985: * @static
10986: */
10987: public static function getPassword()
10988: { //Method inherited from \Symfony\Component\HttpFoundation\Request
10989: /** @var \Illuminate\Http\Request $instance */
10990: return $instance->getPassword();
10991: }
10992: /**
10993: * Gets the user info.
10994: *
10995: * @return string|null A user name if any and, optionally, scheme-specific information about how to gain authorization to access the server
10996: * @static
10997: */
10998: public static function getUserInfo()
10999: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11000: /** @var \Illuminate\Http\Request $instance */
11001: return $instance->getUserInfo();
11002: }
11003: /**
11004: * Returns the HTTP host being requested.
11005: *
11006: * The port name will be appended to the host if it's non-standard.
11007: *
11008: * @static
11009: */
11010: public static function getHttpHost()
11011: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11012: /** @var \Illuminate\Http\Request $instance */
11013: return $instance->getHttpHost();
11014: }
11015: /**
11016: * Returns the requested URI (path and query string).
11017: *
11018: * @return string The raw URI (i.e. not URI decoded)
11019: * @static
11020: */
11021: public static function getRequestUri()
11022: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11023: /** @var \Illuminate\Http\Request $instance */
11024: return $instance->getRequestUri();
11025: }
11026: /**
11027: * Gets the scheme and HTTP host.
11028: *
11029: * If the URL was called with basic authentication, the user
11030: * and the password are not added to the generated string.
11031: *
11032: * @static
11033: */
11034: public static function getSchemeAndHttpHost()
11035: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11036: /** @var \Illuminate\Http\Request $instance */
11037: return $instance->getSchemeAndHttpHost();
11038: }
11039: /**
11040: * Generates a normalized URI (URL) for the Request.
11041: *
11042: * @see getQueryString()
11043: * @static
11044: */
11045: public static function getUri()
11046: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11047: /** @var \Illuminate\Http\Request $instance */
11048: return $instance->getUri();
11049: }
11050: /**
11051: * Generates a normalized URI for the given path.
11052: *
11053: * @param string $path A path to use instead of the current one
11054: * @static
11055: */
11056: public static function getUriForPath($path)
11057: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11058: /** @var \Illuminate\Http\Request $instance */
11059: return $instance->getUriForPath($path);
11060: }
11061: /**
11062: * Returns the path as relative reference from the current Request path.
11063: *
11064: * Only the URIs path component (no schema, host etc.) is relevant and must be given.
11065: * Both paths must be absolute and not contain relative parts.
11066: * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives.
11067: * Furthermore, they can be used to reduce the link size in documents.
11068: *
11069: * Example target paths, given a base path of "/a/b/c/d":
11070: * - "/a/b/c/d" -> ""
11071: * - "/a/b/c/" -> "./"
11072: * - "/a/b/" -> "../"
11073: * - "/a/b/c/other" -> "other"
11074: * - "/a/x/y" -> "../../x/y"
11075: *
11076: * @static
11077: */
11078: public static function getRelativeUriForPath($path)
11079: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11080: /** @var \Illuminate\Http\Request $instance */
11081: return $instance->getRelativeUriForPath($path);
11082: }
11083: /**
11084: * Generates the normalized query string for the Request.
11085: *
11086: * It builds a normalized query string, where keys/value pairs are alphabetized
11087: * and have consistent escaping.
11088: *
11089: * @static
11090: */
11091: public static function getQueryString()
11092: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11093: /** @var \Illuminate\Http\Request $instance */
11094: return $instance->getQueryString();
11095: }
11096: /**
11097: * Checks whether the request is secure or not.
11098: *
11099: * This method can read the client protocol from the "X-Forwarded-Proto" header
11100: * when trusted proxies were set via "setTrustedProxies()".
11101: *
11102: * The "X-Forwarded-Proto" header must contain the protocol: "https" or "http".
11103: *
11104: * @static
11105: */
11106: public static function isSecure()
11107: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11108: /** @var \Illuminate\Http\Request $instance */
11109: return $instance->isSecure();
11110: }
11111: /**
11112: * Returns the host name.
11113: *
11114: * This method can read the client host name from the "X-Forwarded-Host" header
11115: * when trusted proxies were set via "setTrustedProxies()".
11116: *
11117: * The "X-Forwarded-Host" header must contain the client host name.
11118: *
11119: * @throws SuspiciousOperationException when the host name is invalid or not trusted
11120: * @static
11121: */
11122: public static function getHost()
11123: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11124: /** @var \Illuminate\Http\Request $instance */
11125: return $instance->getHost();
11126: }
11127: /**
11128: * Sets the request method.
11129: *
11130: * @static
11131: */
11132: public static function setMethod($method)
11133: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11134: /** @var \Illuminate\Http\Request $instance */
11135: return $instance->setMethod($method);
11136: }
11137: /**
11138: * Gets the request "intended" method.
11139: *
11140: * If the X-HTTP-Method-Override header is set, and if the method is a POST,
11141: * then it is used to determine the "real" intended HTTP method.
11142: *
11143: * The _method request parameter can also be used to determine the HTTP method,
11144: * but only if enableHttpMethodParameterOverride() has been called.
11145: *
11146: * The method is always an uppercased string.
11147: *
11148: * @see getRealMethod()
11149: * @static
11150: */
11151: public static function getMethod()
11152: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11153: /** @var \Illuminate\Http\Request $instance */
11154: return $instance->getMethod();
11155: }
11156: /**
11157: * Gets the "real" request method.
11158: *
11159: * @see getMethod()
11160: * @static
11161: */
11162: public static function getRealMethod()
11163: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11164: /** @var \Illuminate\Http\Request $instance */
11165: return $instance->getRealMethod();
11166: }
11167: /**
11168: * Gets the mime type associated with the format.
11169: *
11170: * @static
11171: */
11172: public static function getMimeType($format)
11173: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11174: /** @var \Illuminate\Http\Request $instance */
11175: return $instance->getMimeType($format);
11176: }
11177: /**
11178: * Gets the mime types associated with the format.
11179: *
11180: * @static
11181: */
11182: public static function getMimeTypes($format)
11183: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11184: return \Illuminate\Http\Request::getMimeTypes($format);
11185: }
11186: /**
11187: * Gets the format associated with the mime type.
11188: *
11189: * @static
11190: */
11191: public static function getFormat($mimeType)
11192: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11193: /** @var \Illuminate\Http\Request $instance */
11194: return $instance->getFormat($mimeType);
11195: }
11196: /**
11197: * Associates a format with mime types.
11198: *
11199: * @param string|array $mimeTypes The associated mime types (the preferred one must be the first as it will be used as the content type)
11200: * @static
11201: */
11202: public static function setFormat($format, $mimeTypes)
11203: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11204: /** @var \Illuminate\Http\Request $instance */
11205: return $instance->setFormat($format, $mimeTypes);
11206: }
11207: /**
11208: * Gets the request format.
11209: *
11210: * Here is the process to determine the format:
11211: *
11212: * * format defined by the user (with setRequestFormat())
11213: * * _format request attribute
11214: * * $default
11215: *
11216: * @see getPreferredFormat
11217: * @static
11218: */
11219: public static function getRequestFormat($default = 'html')
11220: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11221: /** @var \Illuminate\Http\Request $instance */
11222: return $instance->getRequestFormat($default);
11223: }
11224: /**
11225: * Sets the request format.
11226: *
11227: * @static
11228: */
11229: public static function setRequestFormat($format)
11230: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11231: /** @var \Illuminate\Http\Request $instance */
11232: return $instance->setRequestFormat($format);
11233: }
11234: /**
11235: * Gets the format associated with the request.
11236: *
11237: * @static
11238: */
11239: public static function getContentType()
11240: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11241: /** @var \Illuminate\Http\Request $instance */
11242: return $instance->getContentType();
11243: }
11244: /**
11245: * Sets the default locale.
11246: *
11247: * @static
11248: */
11249: public static function setDefaultLocale($locale)
11250: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11251: /** @var \Illuminate\Http\Request $instance */
11252: return $instance->setDefaultLocale($locale);
11253: }
11254: /**
11255: * Get the default locale.
11256: *
11257: * @static
11258: */
11259: public static function getDefaultLocale()
11260: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11261: /** @var \Illuminate\Http\Request $instance */
11262: return $instance->getDefaultLocale();
11263: }
11264: /**
11265: * Sets the locale.
11266: *
11267: * @static
11268: */
11269: public static function setLocale($locale)
11270: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11271: /** @var \Illuminate\Http\Request $instance */
11272: return $instance->setLocale($locale);
11273: }
11274: /**
11275: * Get the locale.
11276: *
11277: * @static
11278: */
11279: public static function getLocale()
11280: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11281: /** @var \Illuminate\Http\Request $instance */
11282: return $instance->getLocale();
11283: }
11284: /**
11285: * Checks if the request method is of specified type.
11286: *
11287: * @param string $method Uppercase request method (GET, POST etc)
11288: * @static
11289: */
11290: public static function isMethod($method)
11291: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11292: /** @var \Illuminate\Http\Request $instance */
11293: return $instance->isMethod($method);
11294: }
11295: /**
11296: * Checks whether or not the method is safe.
11297: *
11298: * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
11299: * @static
11300: */
11301: public static function isMethodSafe()
11302: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11303: /** @var \Illuminate\Http\Request $instance */
11304: return $instance->isMethodSafe();
11305: }
11306: /**
11307: * Checks whether or not the method is idempotent.
11308: *
11309: * @static
11310: */
11311: public static function isMethodIdempotent()
11312: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11313: /** @var \Illuminate\Http\Request $instance */
11314: return $instance->isMethodIdempotent();
11315: }
11316: /**
11317: * Checks whether the method is cacheable or not.
11318: *
11319: * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
11320: * @static
11321: */
11322: public static function isMethodCacheable()
11323: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11324: /** @var \Illuminate\Http\Request $instance */
11325: return $instance->isMethodCacheable();
11326: }
11327: /**
11328: * Returns the protocol version.
11329: *
11330: * If the application is behind a proxy, the protocol version used in the
11331: * requests between the client and the proxy and between the proxy and the
11332: * server might be different. This returns the former (from the "Via" header)
11333: * if the proxy is trusted (see "setTrustedProxies()"), otherwise it returns
11334: * the latter (from the "SERVER_PROTOCOL" server parameter).
11335: *
11336: * @static
11337: */
11338: public static function getProtocolVersion()
11339: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11340: /** @var \Illuminate\Http\Request $instance */
11341: return $instance->getProtocolVersion();
11342: }
11343: /**
11344: * Returns the request body content.
11345: *
11346: * @param bool $asResource If true, a resource will be returned
11347: * @return string|resource
11348: * @static
11349: */
11350: public static function getContent($asResource = false)
11351: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11352: /** @var \Illuminate\Http\Request $instance */
11353: return $instance->getContent($asResource);
11354: }
11355: /**
11356: * Gets the Etags.
11357: *
11358: * @static
11359: */
11360: public static function getETags()
11361: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11362: /** @var \Illuminate\Http\Request $instance */
11363: return $instance->getETags();
11364: }
11365: /**
11366: *
11367: *
11368: * @static
11369: */
11370: public static function isNoCache()
11371: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11372: /** @var \Illuminate\Http\Request $instance */
11373: return $instance->isNoCache();
11374: }
11375: /**
11376: * Gets the preferred format for the response by inspecting, in the following order:
11377: * * the request format set using setRequestFormat;
11378: * * the values of the Accept HTTP header.
11379: *
11380: * Note that if you use this method, you should send the "Vary: Accept" header
11381: * in the response to prevent any issues with intermediary HTTP caches.
11382: *
11383: * @static
11384: */
11385: public static function getPreferredFormat($default = 'html')
11386: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11387: /** @var \Illuminate\Http\Request $instance */
11388: return $instance->getPreferredFormat($default);
11389: }
11390: /**
11391: * Returns the preferred language.
11392: *
11393: * @param string[] $locales An array of ordered available locales
11394: * @static
11395: */
11396: public static function getPreferredLanguage($locales = null)
11397: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11398: /** @var \Illuminate\Http\Request $instance */
11399: return $instance->getPreferredLanguage($locales);
11400: }
11401: /**
11402: * Gets a list of languages acceptable by the client browser ordered in the user browser preferences.
11403: *
11404: * @static
11405: */
11406: public static function getLanguages()
11407: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11408: /** @var \Illuminate\Http\Request $instance */
11409: return $instance->getLanguages();
11410: }
11411: /**
11412: * Gets a list of charsets acceptable by the client browser in preferable order.
11413: *
11414: * @static
11415: */
11416: public static function getCharsets()
11417: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11418: /** @var \Illuminate\Http\Request $instance */
11419: return $instance->getCharsets();
11420: }
11421: /**
11422: * Gets a list of encodings acceptable by the client browser in preferable order.
11423: *
11424: * @static
11425: */
11426: public static function getEncodings()
11427: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11428: /** @var \Illuminate\Http\Request $instance */
11429: return $instance->getEncodings();
11430: }
11431: /**
11432: * Gets a list of content types acceptable by the client browser in preferable order.
11433: *
11434: * @static
11435: */
11436: public static function getAcceptableContentTypes()
11437: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11438: /** @var \Illuminate\Http\Request $instance */
11439: return $instance->getAcceptableContentTypes();
11440: }
11441: /**
11442: * Returns true if the request is an XMLHttpRequest.
11443: *
11444: * It works if your JavaScript library sets an X-Requested-With HTTP header.
11445: * It is known to work with common JavaScript frameworks:
11446: *
11447: * @see https://wikipedia.org/wiki/List_of_Ajax_frameworks#JavaScript
11448: * @static
11449: */
11450: public static function isXmlHttpRequest()
11451: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11452: /** @var \Illuminate\Http\Request $instance */
11453: return $instance->isXmlHttpRequest();
11454: }
11455: /**
11456: * Checks whether the client browser prefers safe content or not according to RFC8674.
11457: *
11458: * @see https://tools.ietf.org/html/rfc8674
11459: * @static
11460: */
11461: public static function preferSafeContent()
11462: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11463: /** @var \Illuminate\Http\Request $instance */
11464: return $instance->preferSafeContent();
11465: }
11466: /**
11467: * Indicates whether this request originated from a trusted proxy.
11468: *
11469: * This can be useful to determine whether or not to trust the
11470: * contents of a proxy-specific header.
11471: *
11472: * @static
11473: */
11474: public static function isFromTrustedProxy()
11475: { //Method inherited from \Symfony\Component\HttpFoundation\Request
11476: /** @var \Illuminate\Http\Request $instance */
11477: return $instance->isFromTrustedProxy();
11478: }
11479: /**
11480: * Determine if the request is sending JSON.
11481: *
11482: * @return bool
11483: * @static
11484: */
11485: public static function isJson()
11486: {
11487: /** @var \Illuminate\Http\Request $instance */
11488: return $instance->isJson();
11489: }
11490: /**
11491: * Determine if the current request probably expects a JSON response.
11492: *
11493: * @return bool
11494: * @static
11495: */
11496: public static function expectsJson()
11497: {
11498: /** @var \Illuminate\Http\Request $instance */
11499: return $instance->expectsJson();
11500: }
11501: /**
11502: * Determine if the current request is asking for JSON.
11503: *
11504: * @return bool
11505: * @static
11506: */
11507: public static function wantsJson()
11508: {
11509: /** @var \Illuminate\Http\Request $instance */
11510: return $instance->wantsJson();
11511: }
11512: /**
11513: * Determines whether the current requests accepts a given content type.
11514: *
11515: * @param string|array $contentTypes
11516: * @return bool
11517: * @static
11518: */
11519: public static function accepts($contentTypes)
11520: {
11521: /** @var \Illuminate\Http\Request $instance */
11522: return $instance->accepts($contentTypes);
11523: }
11524: /**
11525: * Return the most suitable content type from the given array based on content negotiation.
11526: *
11527: * @param string|array $contentTypes
11528: * @return string|null
11529: * @static
11530: */
11531: public static function prefers($contentTypes)
11532: {
11533: /** @var \Illuminate\Http\Request $instance */
11534: return $instance->prefers($contentTypes);
11535: }
11536: /**
11537: * Determine if the current request accepts any content type.
11538: *
11539: * @return bool
11540: * @static
11541: */
11542: public static function acceptsAnyContentType()
11543: {
11544: /** @var \Illuminate\Http\Request $instance */
11545: return $instance->acceptsAnyContentType();
11546: }
11547: /**
11548: * Determines whether a request accepts JSON.
11549: *
11550: * @return bool
11551: * @static
11552: */
11553: public static function acceptsJson()
11554: {
11555: /** @var \Illuminate\Http\Request $instance */
11556: return $instance->acceptsJson();
11557: }
11558: /**
11559: * Determines whether a request accepts HTML.
11560: *
11561: * @return bool
11562: * @static
11563: */
11564: public static function acceptsHtml()
11565: {
11566: /** @var \Illuminate\Http\Request $instance */
11567: return $instance->acceptsHtml();
11568: }
11569: /**
11570: * Determine if the given content types match.
11571: *
11572: * @param string $actual
11573: * @param string $type
11574: * @return bool
11575: * @static
11576: */
11577: public static function matchesType($actual, $type)
11578: {
11579: return \Illuminate\Http\Request::matchesType($actual, $type);
11580: }
11581: /**
11582: * Get the data format expected in the response.
11583: *
11584: * @param string $default
11585: * @return string
11586: * @static
11587: */
11588: public static function format($default = 'html')
11589: {
11590: /** @var \Illuminate\Http\Request $instance */
11591: return $instance->format($default);
11592: }
11593: /**
11594: * Retrieve an old input item.
11595: *
11596: * @param string|null $key
11597: * @param \Illuminate\Database\Eloquent\Model|string|array|null $default
11598: * @return string|array|null
11599: * @static
11600: */
11601: public static function old($key = null, $default = null)
11602: {
11603: /** @var \Illuminate\Http\Request $instance */
11604: return $instance->old($key, $default);
11605: }
11606: /**
11607: * Flash the input for the current request to the session.
11608: *
11609: * @return void
11610: * @static
11611: */
11612: public static function flash()
11613: {
11614: /** @var \Illuminate\Http\Request $instance */
11615: $instance->flash();
11616: }
11617: /**
11618: * Flash only some of the input to the session.
11619: *
11620: * @param array|mixed $keys
11621: * @return void
11622: * @static
11623: */
11624: public static function flashOnly($keys)
11625: {
11626: /** @var \Illuminate\Http\Request $instance */
11627: $instance->flashOnly($keys);
11628: }
11629: /**
11630: * Flash only some of the input to the session.
11631: *
11632: * @param array|mixed $keys
11633: * @return void
11634: * @static
11635: */
11636: public static function flashExcept($keys)
11637: {
11638: /** @var \Illuminate\Http\Request $instance */
11639: $instance->flashExcept($keys);
11640: }
11641: /**
11642: * Flush all of the old input from the session.
11643: *
11644: * @return void
11645: * @static
11646: */
11647: public static function flush()
11648: {
11649: /** @var \Illuminate\Http\Request $instance */
11650: $instance->flush();
11651: }
11652: /**
11653: * Retrieve a server variable from the request.
11654: *
11655: * @param string|null $key
11656: * @param string|array|null $default
11657: * @return string|array|null
11658: * @static
11659: */
11660: public static function server($key = null, $default = null)
11661: {
11662: /** @var \Illuminate\Http\Request $instance */
11663: return $instance->server($key, $default);
11664: }
11665: /**
11666: * Determine if a header is set on the request.
11667: *
11668: * @param string $key
11669: * @return bool
11670: * @static
11671: */
11672: public static function hasHeader($key)
11673: {
11674: /** @var \Illuminate\Http\Request $instance */
11675: return $instance->hasHeader($key);
11676: }
11677: /**
11678: * Retrieve a header from the request.
11679: *
11680: * @param string|null $key
11681: * @param string|array|null $default
11682: * @return string|array|null
11683: * @static
11684: */
11685: public static function header($key = null, $default = null)
11686: {
11687: /** @var \Illuminate\Http\Request $instance */
11688: return $instance->header($key, $default);
11689: }
11690: /**
11691: * Get the bearer token from the request headers.
11692: *
11693: * @return string|null
11694: * @static
11695: */
11696: public static function bearerToken()
11697: {
11698: /** @var \Illuminate\Http\Request $instance */
11699: return $instance->bearerToken();
11700: }
11701: /**
11702: * Determine if the request contains a given input item key.
11703: *
11704: * @param string|array $key
11705: * @return bool
11706: * @static
11707: */
11708: public static function exists($key)
11709: {
11710: /** @var \Illuminate\Http\Request $instance */
11711: return $instance->exists($key);
11712: }
11713: /**
11714: * Determine if the request contains a given input item key.
11715: *
11716: * @param string|array $key
11717: * @return bool
11718: * @static
11719: */
11720: public static function has($key)
11721: {
11722: /** @var \Illuminate\Http\Request $instance */
11723: return $instance->has($key);
11724: }
11725: /**
11726: * Determine if the request contains any of the given inputs.
11727: *
11728: * @param string|array $keys
11729: * @return bool
11730: * @static
11731: */
11732: public static function hasAny($keys)
11733: {
11734: /** @var \Illuminate\Http\Request $instance */
11735: return $instance->hasAny($keys);
11736: }
11737: /**
11738: * Apply the callback if the request contains the given input item key.
11739: *
11740: * @param string $key
11741: * @param callable $callback
11742: * @param callable|null $default
11743: * @return $this|mixed
11744: * @static
11745: */
11746: public static function whenHas($key, $callback, $default = null)
11747: {
11748: /** @var \Illuminate\Http\Request $instance */
11749: return $instance->whenHas($key, $callback, $default);
11750: }
11751: /**
11752: * Determine if the request contains a non-empty value for an input item.
11753: *
11754: * @param string|array $key
11755: * @return bool
11756: * @static
11757: */
11758: public static function filled($key)
11759: {
11760: /** @var \Illuminate\Http\Request $instance */
11761: return $instance->filled($key);
11762: }
11763: /**
11764: * Determine if the request contains an empty value for an input item.
11765: *
11766: * @param string|array $key
11767: * @return bool
11768: * @static
11769: */
11770: public static function isNotFilled($key)
11771: {
11772: /** @var \Illuminate\Http\Request $instance */
11773: return $instance->isNotFilled($key);
11774: }
11775: /**
11776: * Determine if the request contains a non-empty value for any of the given inputs.
11777: *
11778: * @param string|array $keys
11779: * @return bool
11780: * @static
11781: */
11782: public static function anyFilled($keys)
11783: {
11784: /** @var \Illuminate\Http\Request $instance */
11785: return $instance->anyFilled($keys);
11786: }
11787: /**
11788: * Apply the callback if the request contains a non-empty value for the given input item key.
11789: *
11790: * @param string $key
11791: * @param callable $callback
11792: * @param callable|null $default
11793: * @return $this|mixed
11794: * @static
11795: */
11796: public static function whenFilled($key, $callback, $default = null)
11797: {
11798: /** @var \Illuminate\Http\Request $instance */
11799: return $instance->whenFilled($key, $callback, $default);
11800: }
11801: /**
11802: * Determine if the request is missing a given input item key.
11803: *
11804: * @param string|array $key
11805: * @return bool
11806: * @static
11807: */
11808: public static function missing($key)
11809: {
11810: /** @var \Illuminate\Http\Request $instance */
11811: return $instance->missing($key);
11812: }
11813: /**
11814: * Get the keys for all of the input and files.
11815: *
11816: * @return array
11817: * @static
11818: */
11819: public static function keys()
11820: {
11821: /** @var \Illuminate\Http\Request $instance */
11822: return $instance->keys();
11823: }
11824: /**
11825: * Get all of the input and files for the request.
11826: *
11827: * @param array|mixed|null $keys
11828: * @return array
11829: * @static
11830: */
11831: public static function all($keys = null)
11832: {
11833: /** @var \Illuminate\Http\Request $instance */
11834: return $instance->all($keys);
11835: }
11836: /**
11837: * Retrieve an input item from the request.
11838: *
11839: * @param string|null $key
11840: * @param mixed $default
11841: * @return mixed
11842: * @static
11843: */
11844: public static function input($key = null, $default = null)
11845: {
11846: /** @var \Illuminate\Http\Request $instance */
11847: return $instance->input($key, $default);
11848: }
11849: /**
11850: * Retrieve input from the request as a Stringable instance.
11851: *
11852: * @param string $key
11853: * @param mixed $default
11854: * @return \Illuminate\Support\Stringable
11855: * @static
11856: */
11857: public static function str($key, $default = null)
11858: {
11859: /** @var \Illuminate\Http\Request $instance */
11860: return $instance->str($key, $default);
11861: }
11862: /**
11863: * Retrieve input from the request as a Stringable instance.
11864: *
11865: * @param string $key
11866: * @param mixed $default
11867: * @return \Illuminate\Support\Stringable
11868: * @static
11869: */
11870: public static function string($key, $default = null)
11871: {
11872: /** @var \Illuminate\Http\Request $instance */
11873: return $instance->string($key, $default);
11874: }
11875: /**
11876: * Retrieve input as a boolean value.
11877: *
11878: * Returns true when value is "1", "true", "on", and "yes". Otherwise, returns false.
11879: *
11880: * @param string|null $key
11881: * @param bool $default
11882: * @return bool
11883: * @static
11884: */
11885: public static function boolean($key = null, $default = false)
11886: {
11887: /** @var \Illuminate\Http\Request $instance */
11888: return $instance->boolean($key, $default);
11889: }
11890: /**
11891: * Retrieve input from the request as a Carbon instance.
11892: *
11893: * @param string $key
11894: * @param string|null $format
11895: * @param string|null $tz
11896: * @return \Illuminate\Support\Carbon|null
11897: * @static
11898: */
11899: public static function date($key, $format = null, $tz = null)
11900: {
11901: /** @var \Illuminate\Http\Request $instance */
11902: return $instance->date($key, $format, $tz);
11903: }
11904: /**
11905: * Retrieve input from the request as an enum.
11906: *
11907: * @param string $key
11908: * @param string $enumClass
11909: * @return mixed|null
11910: * @static
11911: */
11912: public static function enum($key, $enumClass)
11913: {
11914: /** @var \Illuminate\Http\Request $instance */
11915: return $instance->enum($key, $enumClass);
11916: }
11917: /**
11918: * Retrieve input from the request as a collection.
11919: *
11920: * @param array|string|null $key
11921: * @return \Illuminate\Support\Collection
11922: * @static
11923: */
11924: public static function collect($key = null)
11925: {
11926: /** @var \Illuminate\Http\Request $instance */
11927: return $instance->collect($key);
11928: }
11929: /**
11930: * Get a subset containing the provided keys with values from the input data.
11931: *
11932: * @param array|mixed $keys
11933: * @return array
11934: * @static
11935: */
11936: public static function only($keys)
11937: {
11938: /** @var \Illuminate\Http\Request $instance */
11939: return $instance->only($keys);
11940: }
11941: /**
11942: * Get all of the input except for a specified array of items.
11943: *
11944: * @param array|mixed $keys
11945: * @return array
11946: * @static
11947: */
11948: public static function except($keys)
11949: {
11950: /** @var \Illuminate\Http\Request $instance */
11951: return $instance->except($keys);
11952: }
11953: /**
11954: * Retrieve a query string item from the request.
11955: *
11956: * @param string|null $key
11957: * @param string|array|null $default
11958: * @return string|array|null
11959: * @static
11960: */
11961: public static function query($key = null, $default = null)
11962: {
11963: /** @var \Illuminate\Http\Request $instance */
11964: return $instance->query($key, $default);
11965: }
11966: /**
11967: * Retrieve a request payload item from the request.
11968: *
11969: * @param string|null $key
11970: * @param string|array|null $default
11971: * @return string|array|null
11972: * @static
11973: */
11974: public static function post($key = null, $default = null)
11975: {
11976: /** @var \Illuminate\Http\Request $instance */
11977: return $instance->post($key, $default);
11978: }
11979: /**
11980: * Determine if a cookie is set on the request.
11981: *
11982: * @param string $key
11983: * @return bool
11984: * @static
11985: */
11986: public static function hasCookie($key)
11987: {
11988: /** @var \Illuminate\Http\Request $instance */
11989: return $instance->hasCookie($key);
11990: }
11991: /**
11992: * Retrieve a cookie from the request.
11993: *
11994: * @param string|null $key
11995: * @param string|array|null $default
11996: * @return string|array|null
11997: * @static
11998: */
11999: public static function cookie($key = null, $default = null)
12000: {
12001: /** @var \Illuminate\Http\Request $instance */
12002: return $instance->cookie($key, $default);
12003: }
12004: /**
12005: * Get an array of all of the files on the request.
12006: *
12007: * @return array
12008: * @static
12009: */
12010: public static function allFiles()
12011: {
12012: /** @var \Illuminate\Http\Request $instance */
12013: return $instance->allFiles();
12014: }
12015: /**
12016: * Determine if the uploaded data contains a file.
12017: *
12018: * @param string $key
12019: * @return bool
12020: * @static
12021: */
12022: public static function hasFile($key)
12023: {
12024: /** @var \Illuminate\Http\Request $instance */
12025: return $instance->hasFile($key);
12026: }
12027: /**
12028: * Retrieve a file from the request.
12029: *
12030: * @param string|null $key
12031: * @param mixed $default
12032: * @return \Illuminate\Http\UploadedFile|\Illuminate\Http\UploadedFile[]|array|null
12033: * @static
12034: */
12035: public static function file($key = null, $default = null)
12036: {
12037: /** @var \Illuminate\Http\Request $instance */
12038: return $instance->file($key, $default);
12039: }
12040: /**
12041: * Dump the request items and end the script.
12042: *
12043: * @param mixed $keys
12044: * @return void
12045: * @static
12046: */
12047: public static function dd(...$keys)
12048: {
12049: /** @var \Illuminate\Http\Request $instance */
12050: $instance->dd(...$keys);
12051: }
12052: /**
12053: * Dump the items.
12054: *
12055: * @param mixed $keys
12056: * @return \Illuminate\Http\Request
12057: * @static
12058: */
12059: public static function dump($keys = [])
12060: {
12061: /** @var \Illuminate\Http\Request $instance */
12062: return $instance->dump($keys);
12063: }
12064: /**
12065: * Register a custom macro.
12066: *
12067: * @param string $name
12068: * @param object|callable $macro
12069: * @return void
12070: * @static
12071: */
12072: public static function macro($name, $macro)
12073: {
12074: \Illuminate\Http\Request::macro($name, $macro);
12075: }
12076: /**
12077: * Mix another object into the class.
12078: *
12079: * @param object $mixin
12080: * @param bool $replace
12081: * @return void
12082: * @throws \ReflectionException
12083: * @static
12084: */
12085: public static function mixin($mixin, $replace = true)
12086: {
12087: \Illuminate\Http\Request::mixin($mixin, $replace);
12088: }
12089: /**
12090: * Checks if macro is registered.
12091: *
12092: * @param string $name
12093: * @return bool
12094: * @static
12095: */
12096: public static function hasMacro($name)
12097: {
12098: return \Illuminate\Http\Request::hasMacro($name);
12099: }
12100: /**
12101: * Flush the existing macros.
12102: *
12103: * @return void
12104: * @static
12105: */
12106: public static function flushMacros()
12107: {
12108: \Illuminate\Http\Request::flushMacros();
12109: }
12110: /**
12111: *
12112: *
12113: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
12114: * @param array $rules
12115: * @param mixed $params
12116: * @static
12117: */
12118: public static function validate($rules, ...$params)
12119: {
12120: return \Illuminate\Http\Request::validate($rules, ...$params);
12121: }
12122: /**
12123: *
12124: *
12125: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
12126: * @param string $errorBag
12127: * @param array $rules
12128: * @param mixed $params
12129: * @static
12130: */
12131: public static function validateWithBag($errorBag, $rules, ...$params)
12132: {
12133: return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params);
12134: }
12135: /**
12136: *
12137: *
12138: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12139: * @param mixed $absolute
12140: * @static
12141: */
12142: public static function hasValidSignature($absolute = true)
12143: {
12144: return \Illuminate\Http\Request::hasValidSignature($absolute);
12145: }
12146: /**
12147: *
12148: *
12149: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12150: * @static
12151: */
12152: public static function hasValidRelativeSignature()
12153: {
12154: return \Illuminate\Http\Request::hasValidRelativeSignature();
12155: }
12156: /**
12157: *
12158: *
12159: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
12160: * @param mixed $ignoreQuery
12161: * @param mixed $absolute
12162: * @static
12163: */
12164: public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true)
12165: {
12166: return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute);
12167: }
12168:
12169: }
12170: /**
12171: *
12172: *
12173: * @see \Illuminate\Contracts\Routing\ResponseFactory
12174: */
12175: class Response {
12176: /**
12177: * Create a new response instance.
12178: *
12179: * @param mixed $content
12180: * @param int $status
12181: * @param array $headers
12182: * @return \Illuminate\Http\Response
12183: * @static
12184: */
12185: public static function make($content = '', $status = 200, $headers = [])
12186: {
12187: /** @var \Illuminate\Routing\ResponseFactory $instance */
12188: return $instance->make($content, $status, $headers);
12189: }
12190: /**
12191: * Create a new "no content" response.
12192: *
12193: * @param int $status
12194: * @param array $headers
12195: * @return \Illuminate\Http\Response
12196: * @static
12197: */
12198: public static function noContent($status = 204, $headers = [])
12199: {
12200: /** @var \Illuminate\Routing\ResponseFactory $instance */
12201: return $instance->noContent($status, $headers);
12202: }
12203: /**
12204: * Create a new response for a given view.
12205: *
12206: * @param string|array $view
12207: * @param array $data
12208: * @param int $status
12209: * @param array $headers
12210: * @return \Illuminate\Http\Response
12211: * @static
12212: */
12213: public static function view($view, $data = [], $status = 200, $headers = [])
12214: {
12215: /** @var \Illuminate\Routing\ResponseFactory $instance */
12216: return $instance->view($view, $data, $status, $headers);
12217: }
12218: /**
12219: * Create a new JSON response instance.
12220: *
12221: * @param mixed $data
12222: * @param int $status
12223: * @param array $headers
12224: * @param int $options
12225: * @return \Illuminate\Http\JsonResponse
12226: * @static
12227: */
12228: public static function json($data = [], $status = 200, $headers = [], $options = 0)
12229: {
12230: /** @var \Illuminate\Routing\ResponseFactory $instance */
12231: return $instance->json($data, $status, $headers, $options);
12232: }
12233: /**
12234: * Create a new JSONP response instance.
12235: *
12236: * @param string $callback
12237: * @param mixed $data
12238: * @param int $status
12239: * @param array $headers
12240: * @param int $options
12241: * @return \Illuminate\Http\JsonResponse
12242: * @static
12243: */
12244: public static function jsonp($callback, $data = [], $status = 200, $headers = [], $options = 0)
12245: {
12246: /** @var \Illuminate\Routing\ResponseFactory $instance */
12247: return $instance->jsonp($callback, $data, $status, $headers, $options);
12248: }
12249: /**
12250: * Create a new streamed response instance.
12251: *
12252: * @param \Closure $callback
12253: * @param int $status
12254: * @param array $headers
12255: * @return \Symfony\Component\HttpFoundation\StreamedResponse
12256: * @static
12257: */
12258: public static function stream($callback, $status = 200, $headers = [])
12259: {
12260: /** @var \Illuminate\Routing\ResponseFactory $instance */
12261: return $instance->stream($callback, $status, $headers);
12262: }
12263: /**
12264: * Create a new streamed response instance as a file download.
12265: *
12266: * @param \Closure $callback
12267: * @param string|null $name
12268: * @param array $headers
12269: * @param string|null $disposition
12270: * @return \Symfony\Component\HttpFoundation\StreamedResponse
12271: * @static
12272: */
12273: public static function streamDownload($callback, $name = null, $headers = [], $disposition = 'attachment')
12274: {
12275: /** @var \Illuminate\Routing\ResponseFactory $instance */
12276: return $instance->streamDownload($callback, $name, $headers, $disposition);
12277: }
12278: /**
12279: * Create a new file download response.
12280: *
12281: * @param \SplFileInfo|string $file
12282: * @param string|null $name
12283: * @param array $headers
12284: * @param string|null $disposition
12285: * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
12286: * @static
12287: */
12288: public static function download($file, $name = null, $headers = [], $disposition = 'attachment')
12289: {
12290: /** @var \Illuminate\Routing\ResponseFactory $instance */
12291: return $instance->download($file, $name, $headers, $disposition);
12292: }
12293: /**
12294: * Return the raw contents of a binary file.
12295: *
12296: * @param \SplFileInfo|string $file
12297: * @param array $headers
12298: * @return \Symfony\Component\HttpFoundation\BinaryFileResponse
12299: * @static
12300: */
12301: public static function file($file, $headers = [])
12302: {
12303: /** @var \Illuminate\Routing\ResponseFactory $instance */
12304: return $instance->file($file, $headers);
12305: }
12306: /**
12307: * Create a new redirect response to the given path.
12308: *
12309: * @param string $path
12310: * @param int $status
12311: * @param array $headers
12312: * @param bool|null $secure
12313: * @return \Illuminate\Http\RedirectResponse
12314: * @static
12315: */
12316: public static function redirectTo($path, $status = 302, $headers = [], $secure = null)
12317: {
12318: /** @var \Illuminate\Routing\ResponseFactory $instance */
12319: return $instance->redirectTo($path, $status, $headers, $secure);
12320: }
12321: /**
12322: * Create a new redirect response to a named route.
12323: *
12324: * @param string $route
12325: * @param mixed $parameters
12326: * @param int $status
12327: * @param array $headers
12328: * @return \Illuminate\Http\RedirectResponse
12329: * @static
12330: */
12331: public static function redirectToRoute($route, $parameters = [], $status = 302, $headers = [])
12332: {
12333: /** @var \Illuminate\Routing\ResponseFactory $instance */
12334: return $instance->redirectToRoute($route, $parameters, $status, $headers);
12335: }
12336: /**
12337: * Create a new redirect response to a controller action.
12338: *
12339: * @param string $action
12340: * @param mixed $parameters
12341: * @param int $status
12342: * @param array $headers
12343: * @return \Illuminate\Http\RedirectResponse
12344: * @static
12345: */
12346: public static function redirectToAction($action, $parameters = [], $status = 302, $headers = [])
12347: {
12348: /** @var \Illuminate\Routing\ResponseFactory $instance */
12349: return $instance->redirectToAction($action, $parameters, $status, $headers);
12350: }
12351: /**
12352: * Create a new redirect response, while putting the current URL in the session.
12353: *
12354: * @param string $path
12355: * @param int $status
12356: * @param array $headers
12357: * @param bool|null $secure
12358: * @return \Illuminate\Http\RedirectResponse
12359: * @static
12360: */
12361: public static function redirectGuest($path, $status = 302, $headers = [], $secure = null)
12362: {
12363: /** @var \Illuminate\Routing\ResponseFactory $instance */
12364: return $instance->redirectGuest($path, $status, $headers, $secure);
12365: }
12366: /**
12367: * Create a new redirect response to the previously intended location.
12368: *
12369: * @param string $default
12370: * @param int $status
12371: * @param array $headers
12372: * @param bool|null $secure
12373: * @return \Illuminate\Http\RedirectResponse
12374: * @static
12375: */
12376: public static function redirectToIntended($default = '/', $status = 302, $headers = [], $secure = null)
12377: {
12378: /** @var \Illuminate\Routing\ResponseFactory $instance */
12379: return $instance->redirectToIntended($default, $status, $headers, $secure);
12380: }
12381: /**
12382: * Register a custom macro.
12383: *
12384: * @param string $name
12385: * @param object|callable $macro
12386: * @return void
12387: * @static
12388: */
12389: public static function macro($name, $macro)
12390: {
12391: \Illuminate\Routing\ResponseFactory::macro($name, $macro);
12392: }
12393: /**
12394: * Mix another object into the class.
12395: *
12396: * @param object $mixin
12397: * @param bool $replace
12398: * @return void
12399: * @throws \ReflectionException
12400: * @static
12401: */
12402: public static function mixin($mixin, $replace = true)
12403: {
12404: \Illuminate\Routing\ResponseFactory::mixin($mixin, $replace);
12405: }
12406: /**
12407: * Checks if macro is registered.
12408: *
12409: * @param string $name
12410: * @return bool
12411: * @static
12412: */
12413: public static function hasMacro($name)
12414: {
12415: return \Illuminate\Routing\ResponseFactory::hasMacro($name);
12416: }
12417: /**
12418: * Flush the existing macros.
12419: *
12420: * @return void
12421: * @static
12422: */
12423: public static function flushMacros()
12424: {
12425: \Illuminate\Routing\ResponseFactory::flushMacros();
12426: }
12427:
12428: }
12429: /**
12430: *
12431: *
12432: * @method static \Illuminate\Routing\RouteRegistrar as(string $value)
12433: * @method static \Illuminate\Routing\RouteRegistrar controller(string $controller)
12434: * @method static \Illuminate\Routing\RouteRegistrar domain(string $value)
12435: * @method static \Illuminate\Routing\RouteRegistrar middleware(array|string|null $middleware)
12436: * @method static \Illuminate\Routing\RouteRegistrar name(string $value)
12437: * @method static \Illuminate\Routing\RouteRegistrar namespace(string|null $value)
12438: * @method static \Illuminate\Routing\RouteRegistrar prefix(string $prefix)
12439: * @method static \Illuminate\Routing\RouteRegistrar scopeBindings()
12440: * @method static \Illuminate\Routing\RouteRegistrar where(array $where)
12441: * @method static \Illuminate\Routing\RouteRegistrar withoutMiddleware(array|string $middleware)
12442: * @see \Illuminate\Routing\Router
12443: */
12444: class Route {
12445: /**
12446: * Register a new GET route with the router.
12447: *
12448: * @param string $uri
12449: * @param array|string|callable|null $action
12450: * @return \Illuminate\Routing\Route
12451: * @static
12452: */
12453: public static function get($uri, $action = null)
12454: {
12455: /** @var \Illuminate\Routing\Router $instance */
12456: return $instance->get($uri, $action);
12457: }
12458: /**
12459: * Register a new POST route with the router.
12460: *
12461: * @param string $uri
12462: * @param array|string|callable|null $action
12463: * @return \Illuminate\Routing\Route
12464: * @static
12465: */
12466: public static function post($uri, $action = null)
12467: {
12468: /** @var \Illuminate\Routing\Router $instance */
12469: return $instance->post($uri, $action);
12470: }
12471: /**
12472: * Register a new PUT route with the router.
12473: *
12474: * @param string $uri
12475: * @param array|string|callable|null $action
12476: * @return \Illuminate\Routing\Route
12477: * @static
12478: */
12479: public static function put($uri, $action = null)
12480: {
12481: /** @var \Illuminate\Routing\Router $instance */
12482: return $instance->put($uri, $action);
12483: }
12484: /**
12485: * Register a new PATCH route with the router.
12486: *
12487: * @param string $uri
12488: * @param array|string|callable|null $action
12489: * @return \Illuminate\Routing\Route
12490: * @static
12491: */
12492: public static function patch($uri, $action = null)
12493: {
12494: /** @var \Illuminate\Routing\Router $instance */
12495: return $instance->patch($uri, $action);
12496: }
12497: /**
12498: * Register a new DELETE route with the router.
12499: *
12500: * @param string $uri
12501: * @param array|string|callable|null $action
12502: * @return \Illuminate\Routing\Route
12503: * @static
12504: */
12505: public static function delete($uri, $action = null)
12506: {
12507: /** @var \Illuminate\Routing\Router $instance */
12508: return $instance->delete($uri, $action);
12509: }
12510: /**
12511: * Register a new OPTIONS route with the router.
12512: *
12513: * @param string $uri
12514: * @param array|string|callable|null $action
12515: * @return \Illuminate\Routing\Route
12516: * @static
12517: */
12518: public static function options($uri, $action = null)
12519: {
12520: /** @var \Illuminate\Routing\Router $instance */
12521: return $instance->options($uri, $action);
12522: }
12523: /**
12524: * Register a new route responding to all verbs.
12525: *
12526: * @param string $uri
12527: * @param array|string|callable|null $action
12528: * @return \Illuminate\Routing\Route
12529: * @static
12530: */
12531: public static function any($uri, $action = null)
12532: {
12533: /** @var \Illuminate\Routing\Router $instance */
12534: return $instance->any($uri, $action);
12535: }
12536: /**
12537: * Register a new Fallback route with the router.
12538: *
12539: * @param array|string|callable|null $action
12540: * @return \Illuminate\Routing\Route
12541: * @static
12542: */
12543: public static function fallback($action)
12544: {
12545: /** @var \Illuminate\Routing\Router $instance */
12546: return $instance->fallback($action);
12547: }
12548: /**
12549: * Create a redirect from one URI to another.
12550: *
12551: * @param string $uri
12552: * @param string $destination
12553: * @param int $status
12554: * @return \Illuminate\Routing\Route
12555: * @static
12556: */
12557: public static function redirect($uri, $destination, $status = 302)
12558: {
12559: /** @var \Illuminate\Routing\Router $instance */
12560: return $instance->redirect($uri, $destination, $status);
12561: }
12562: /**
12563: * Create a permanent redirect from one URI to another.
12564: *
12565: * @param string $uri
12566: * @param string $destination
12567: * @return \Illuminate\Routing\Route
12568: * @static
12569: */
12570: public static function permanentRedirect($uri, $destination)
12571: {
12572: /** @var \Illuminate\Routing\Router $instance */
12573: return $instance->permanentRedirect($uri, $destination);
12574: }
12575: /**
12576: * Register a new route that returns a view.
12577: *
12578: * @param string $uri
12579: * @param string $view
12580: * @param array $data
12581: * @param int|array $status
12582: * @param array $headers
12583: * @return \Illuminate\Routing\Route
12584: * @static
12585: */
12586: public static function view($uri, $view, $data = [], $status = 200, $headers = [])
12587: {
12588: /** @var \Illuminate\Routing\Router $instance */
12589: return $instance->view($uri, $view, $data, $status, $headers);
12590: }
12591: /**
12592: * Register a new route with the given verbs.
12593: *
12594: * @param array|string $methods
12595: * @param string $uri
12596: * @param array|string|callable|null $action
12597: * @return \Illuminate\Routing\Route
12598: * @static
12599: */
12600: public static function match($methods, $uri, $action = null)
12601: {
12602: /** @var \Illuminate\Routing\Router $instance */
12603: return $instance->match($methods, $uri, $action);
12604: }
12605: /**
12606: * Register an array of resource controllers.
12607: *
12608: * @param array $resources
12609: * @param array $options
12610: * @return void
12611: * @static
12612: */
12613: public static function resources($resources, $options = [])
12614: {
12615: /** @var \Illuminate\Routing\Router $instance */
12616: $instance->resources($resources, $options);
12617: }
12618: /**
12619: * Route a resource to a controller.
12620: *
12621: * @param string $name
12622: * @param string $controller
12623: * @param array $options
12624: * @return \Illuminate\Routing\PendingResourceRegistration
12625: * @static
12626: */
12627: public static function resource($name, $controller, $options = [])
12628: {
12629: /** @var \Illuminate\Routing\Router $instance */
12630: return $instance->resource($name, $controller, $options);
12631: }
12632: /**
12633: * Register an array of API resource controllers.
12634: *
12635: * @param array $resources
12636: * @param array $options
12637: * @return void
12638: * @static
12639: */
12640: public static function apiResources($resources, $options = [])
12641: {
12642: /** @var \Illuminate\Routing\Router $instance */
12643: $instance->apiResources($resources, $options);
12644: }
12645: /**
12646: * Route an API resource to a controller.
12647: *
12648: * @param string $name
12649: * @param string $controller
12650: * @param array $options
12651: * @return \Illuminate\Routing\PendingResourceRegistration
12652: * @static
12653: */
12654: public static function apiResource($name, $controller, $options = [])
12655: {
12656: /** @var \Illuminate\Routing\Router $instance */
12657: return $instance->apiResource($name, $controller, $options);
12658: }
12659: /**
12660: * Create a route group with shared attributes.
12661: *
12662: * @param array $attributes
12663: * @param \Closure|array|string $routes
12664: * @return void
12665: * @static
12666: */
12667: public static function group($attributes, $routes)
12668: {
12669: /** @var \Illuminate\Routing\Router $instance */
12670: $instance->group($attributes, $routes);
12671: }
12672: /**
12673: * Merge the given array with the last group stack.
12674: *
12675: * @param array $new
12676: * @param bool $prependExistingPrefix
12677: * @return array
12678: * @static
12679: */
12680: public static function mergeWithLastGroup($new, $prependExistingPrefix = true)
12681: {
12682: /** @var \Illuminate\Routing\Router $instance */
12683: return $instance->mergeWithLastGroup($new, $prependExistingPrefix);
12684: }
12685: /**
12686: * Get the prefix from the last group on the stack.
12687: *
12688: * @return string
12689: * @static
12690: */
12691: public static function getLastGroupPrefix()
12692: {
12693: /** @var \Illuminate\Routing\Router $instance */
12694: return $instance->getLastGroupPrefix();
12695: }
12696: /**
12697: * Add a route to the underlying route collection.
12698: *
12699: * @param array|string $methods
12700: * @param string $uri
12701: * @param array|string|callable|null $action
12702: * @return \Illuminate\Routing\Route
12703: * @static
12704: */
12705: public static function addRoute($methods, $uri, $action)
12706: {
12707: /** @var \Illuminate\Routing\Router $instance */
12708: return $instance->addRoute($methods, $uri, $action);
12709: }
12710: /**
12711: * Create a new Route object.
12712: *
12713: * @param array|string $methods
12714: * @param string $uri
12715: * @param mixed $action
12716: * @return \Illuminate\Routing\Route
12717: * @static
12718: */
12719: public static function newRoute($methods, $uri, $action)
12720: {
12721: /** @var \Illuminate\Routing\Router $instance */
12722: return $instance->newRoute($methods, $uri, $action);
12723: }
12724: /**
12725: * Return the response returned by the given route.
12726: *
12727: * @param string $name
12728: * @return \Symfony\Component\HttpFoundation\Response
12729: * @static
12730: */
12731: public static function respondWithRoute($name)
12732: {
12733: /** @var \Illuminate\Routing\Router $instance */
12734: return $instance->respondWithRoute($name);
12735: }
12736: /**
12737: * Dispatch the request to the application.
12738: *
12739: * @param \Illuminate\Http\Request $request
12740: * @return \Symfony\Component\HttpFoundation\Response
12741: * @static
12742: */
12743: public static function dispatch($request)
12744: {
12745: /** @var \Illuminate\Routing\Router $instance */
12746: return $instance->dispatch($request);
12747: }
12748: /**
12749: * Dispatch the request to a route and return the response.
12750: *
12751: * @param \Illuminate\Http\Request $request
12752: * @return \Symfony\Component\HttpFoundation\Response
12753: * @static
12754: */
12755: public static function dispatchToRoute($request)
12756: {
12757: /** @var \Illuminate\Routing\Router $instance */
12758: return $instance->dispatchToRoute($request);
12759: }
12760: /**
12761: * Gather the middleware for the given route with resolved class names.
12762: *
12763: * @param \Illuminate\Routing\Route $route
12764: * @return array
12765: * @static
12766: */
12767: public static function gatherRouteMiddleware($route)
12768: {
12769: /** @var \Illuminate\Routing\Router $instance */
12770: return $instance->gatherRouteMiddleware($route);
12771: }
12772: /**
12773: * Resolve a flat array of middleware classes from the provided array.
12774: *
12775: * @param array $middleware
12776: * @param array $excluded
12777: * @return array
12778: * @static
12779: */
12780: public static function resolveMiddleware($middleware, $excluded = [])
12781: {
12782: /** @var \Illuminate\Routing\Router $instance */
12783: return $instance->resolveMiddleware($middleware, $excluded);
12784: }
12785: /**
12786: * Create a response instance from the given value.
12787: *
12788: * @param \Symfony\Component\HttpFoundation\Request $request
12789: * @param mixed $response
12790: * @return \Symfony\Component\HttpFoundation\Response
12791: * @static
12792: */
12793: public static function prepareResponse($request, $response)
12794: {
12795: /** @var \Illuminate\Routing\Router $instance */
12796: return $instance->prepareResponse($request, $response);
12797: }
12798: /**
12799: * Static version of prepareResponse.
12800: *
12801: * @param \Symfony\Component\HttpFoundation\Request $request
12802: * @param mixed $response
12803: * @return \Symfony\Component\HttpFoundation\Response
12804: * @static
12805: */
12806: public static function toResponse($request, $response)
12807: {
12808: return \Illuminate\Routing\Router::toResponse($request, $response);
12809: }
12810: /**
12811: * Substitute the route bindings onto the route.
12812: *
12813: * @param \Illuminate\Routing\Route $route
12814: * @return \Illuminate\Routing\Route
12815: * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
12816: * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
12817: * @static
12818: */
12819: public static function substituteBindings($route)
12820: {
12821: /** @var \Illuminate\Routing\Router $instance */
12822: return $instance->substituteBindings($route);
12823: }
12824: /**
12825: * Substitute the implicit route bindings for the given route.
12826: *
12827: * @param \Illuminate\Routing\Route $route
12828: * @return void
12829: * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
12830: * @throws \Illuminate\Routing\Exceptions\BackedEnumCaseNotFoundException
12831: * @static
12832: */
12833: public static function substituteImplicitBindings($route)
12834: {
12835: /** @var \Illuminate\Routing\Router $instance */
12836: $instance->substituteImplicitBindings($route);
12837: }
12838: /**
12839: * Register a route matched event listener.
12840: *
12841: * @param string|callable $callback
12842: * @return void
12843: * @static
12844: */
12845: public static function matched($callback)
12846: {
12847: /** @var \Illuminate\Routing\Router $instance */
12848: $instance->matched($callback);
12849: }
12850: /**
12851: * Get all of the defined middleware short-hand names.
12852: *
12853: * @return array
12854: * @static
12855: */
12856: public static function getMiddleware()
12857: {
12858: /** @var \Illuminate\Routing\Router $instance */
12859: return $instance->getMiddleware();
12860: }
12861: /**
12862: * Register a short-hand name for a middleware.
12863: *
12864: * @param string $name
12865: * @param string $class
12866: * @return \Illuminate\Routing\Router
12867: * @static
12868: */
12869: public static function aliasMiddleware($name, $class)
12870: {
12871: /** @var \Illuminate\Routing\Router $instance */
12872: return $instance->aliasMiddleware($name, $class);
12873: }
12874: /**
12875: * Check if a middlewareGroup with the given name exists.
12876: *
12877: * @param string $name
12878: * @return bool
12879: * @static
12880: */
12881: public static function hasMiddlewareGroup($name)
12882: {
12883: /** @var \Illuminate\Routing\Router $instance */
12884: return $instance->hasMiddlewareGroup($name);
12885: }
12886: /**
12887: * Get all of the defined middleware groups.
12888: *
12889: * @return array
12890: * @static
12891: */
12892: public static function getMiddlewareGroups()
12893: {
12894: /** @var \Illuminate\Routing\Router $instance */
12895: return $instance->getMiddlewareGroups();
12896: }
12897: /**
12898: * Register a group of middleware.
12899: *
12900: * @param string $name
12901: * @param array $middleware
12902: * @return \Illuminate\Routing\Router
12903: * @static
12904: */
12905: public static function middlewareGroup($name, $middleware)
12906: {
12907: /** @var \Illuminate\Routing\Router $instance */
12908: return $instance->middlewareGroup($name, $middleware);
12909: }
12910: /**
12911: * Add a middleware to the beginning of a middleware group.
12912: *
12913: * If the middleware is already in the group, it will not be added again.
12914: *
12915: * @param string $group
12916: * @param string $middleware
12917: * @return \Illuminate\Routing\Router
12918: * @static
12919: */
12920: public static function prependMiddlewareToGroup($group, $middleware)
12921: {
12922: /** @var \Illuminate\Routing\Router $instance */
12923: return $instance->prependMiddlewareToGroup($group, $middleware);
12924: }
12925: /**
12926: * Add a middleware to the end of a middleware group.
12927: *
12928: * If the middleware is already in the group, it will not be added again.
12929: *
12930: * @param string $group
12931: * @param string $middleware
12932: * @return \Illuminate\Routing\Router
12933: * @static
12934: */
12935: public static function pushMiddlewareToGroup($group, $middleware)
12936: {
12937: /** @var \Illuminate\Routing\Router $instance */
12938: return $instance->pushMiddlewareToGroup($group, $middleware);
12939: }
12940: /**
12941: * Flush the router's middleware groups.
12942: *
12943: * @return \Illuminate\Routing\Router
12944: * @static
12945: */
12946: public static function flushMiddlewareGroups()
12947: {
12948: /** @var \Illuminate\Routing\Router $instance */
12949: return $instance->flushMiddlewareGroups();
12950: }
12951: /**
12952: * Add a new route parameter binder.
12953: *
12954: * @param string $key
12955: * @param string|callable $binder
12956: * @return void
12957: * @static
12958: */
12959: public static function bind($key, $binder)
12960: {
12961: /** @var \Illuminate\Routing\Router $instance */
12962: $instance->bind($key, $binder);
12963: }
12964: /**
12965: * Register a model binder for a wildcard.
12966: *
12967: * @param string $key
12968: * @param string $class
12969: * @param \Closure|null $callback
12970: * @return void
12971: * @static
12972: */
12973: public static function model($key, $class, $callback = null)
12974: {
12975: /** @var \Illuminate\Routing\Router $instance */
12976: $instance->model($key, $class, $callback);
12977: }
12978: /**
12979: * Get the binding callback for a given binding.
12980: *
12981: * @param string $key
12982: * @return \Closure|null
12983: * @static
12984: */
12985: public static function getBindingCallback($key)
12986: {
12987: /** @var \Illuminate\Routing\Router $instance */
12988: return $instance->getBindingCallback($key);
12989: }
12990: /**
12991: * Get the global "where" patterns.
12992: *
12993: * @return array
12994: * @static
12995: */
12996: public static function getPatterns()
12997: {
12998: /** @var \Illuminate\Routing\Router $instance */
12999: return $instance->getPatterns();
13000: }
13001: /**
13002: * Set a global where pattern on all routes.
13003: *
13004: * @param string $key
13005: * @param string $pattern
13006: * @return void
13007: * @static
13008: */
13009: public static function pattern($key, $pattern)
13010: {
13011: /** @var \Illuminate\Routing\Router $instance */
13012: $instance->pattern($key, $pattern);
13013: }
13014: /**
13015: * Set a group of global where patterns on all routes.
13016: *
13017: * @param array $patterns
13018: * @return void
13019: * @static
13020: */
13021: public static function patterns($patterns)
13022: {
13023: /** @var \Illuminate\Routing\Router $instance */
13024: $instance->patterns($patterns);
13025: }
13026: /**
13027: * Determine if the router currently has a group stack.
13028: *
13029: * @return bool
13030: * @static
13031: */
13032: public static function hasGroupStack()
13033: {
13034: /** @var \Illuminate\Routing\Router $instance */
13035: return $instance->hasGroupStack();
13036: }
13037: /**
13038: * Get the current group stack for the router.
13039: *
13040: * @return array
13041: * @static
13042: */
13043: public static function getGroupStack()
13044: {
13045: /** @var \Illuminate\Routing\Router $instance */
13046: return $instance->getGroupStack();
13047: }
13048: /**
13049: * Get a route parameter for the current route.
13050: *
13051: * @param string $key
13052: * @param string|null $default
13053: * @return mixed
13054: * @static
13055: */
13056: public static function input($key, $default = null)
13057: {
13058: /** @var \Illuminate\Routing\Router $instance */
13059: return $instance->input($key, $default);
13060: }
13061: /**
13062: * Get the request currently being dispatched.
13063: *
13064: * @return \Illuminate\Http\Request
13065: * @static
13066: */
13067: public static function getCurrentRequest()
13068: {
13069: /** @var \Illuminate\Routing\Router $instance */
13070: return $instance->getCurrentRequest();
13071: }
13072: /**
13073: * Get the currently dispatched route instance.
13074: *
13075: * @return \Illuminate\Routing\Route|null
13076: * @static
13077: */
13078: public static function getCurrentRoute()
13079: {
13080: /** @var \Illuminate\Routing\Router $instance */
13081: return $instance->getCurrentRoute();
13082: }
13083: /**
13084: * Get the currently dispatched route instance.
13085: *
13086: * @return \Illuminate\Routing\Route|null
13087: * @static
13088: */
13089: public static function current()
13090: {
13091: /** @var \Illuminate\Routing\Router $instance */
13092: return $instance->current();
13093: }
13094: /**
13095: * Check if a route with the given name exists.
13096: *
13097: * @param string|array $name
13098: * @return bool
13099: * @static
13100: */
13101: public static function has($name)
13102: {
13103: /** @var \Illuminate\Routing\Router $instance */
13104: return $instance->has($name);
13105: }
13106: /**
13107: * Get the current route name.
13108: *
13109: * @return string|null
13110: * @static
13111: */
13112: public static function currentRouteName()
13113: {
13114: /** @var \Illuminate\Routing\Router $instance */
13115: return $instance->currentRouteName();
13116: }
13117: /**
13118: * Alias for the "currentRouteNamed" method.
13119: *
13120: * @param mixed $patterns
13121: * @return bool
13122: * @static
13123: */
13124: public static function is(...$patterns)
13125: {
13126: /** @var \Illuminate\Routing\Router $instance */
13127: return $instance->is(...$patterns);
13128: }
13129: /**
13130: * Determine if the current route matches a pattern.
13131: *
13132: * @param mixed $patterns
13133: * @return bool
13134: * @static
13135: */
13136: public static function currentRouteNamed(...$patterns)
13137: {
13138: /** @var \Illuminate\Routing\Router $instance */
13139: return $instance->currentRouteNamed(...$patterns);
13140: }
13141: /**
13142: * Get the current route action.
13143: *
13144: * @return string|null
13145: * @static
13146: */
13147: public static function currentRouteAction()
13148: {
13149: /** @var \Illuminate\Routing\Router $instance */
13150: return $instance->currentRouteAction();
13151: }
13152: /**
13153: * Alias for the "currentRouteUses" method.
13154: *
13155: * @param array $patterns
13156: * @return bool
13157: * @static
13158: */
13159: public static function uses(...$patterns)
13160: {
13161: /** @var \Illuminate\Routing\Router $instance */
13162: return $instance->uses(...$patterns);
13163: }
13164: /**
13165: * Determine if the current route action matches a given action.
13166: *
13167: * @param string $action
13168: * @return bool
13169: * @static
13170: */
13171: public static function currentRouteUses($action)
13172: {
13173: /** @var \Illuminate\Routing\Router $instance */
13174: return $instance->currentRouteUses($action);
13175: }
13176: /**
13177: * Set the unmapped global resource parameters to singular.
13178: *
13179: * @param bool $singular
13180: * @return void
13181: * @static
13182: */
13183: public static function singularResourceParameters($singular = true)
13184: {
13185: /** @var \Illuminate\Routing\Router $instance */
13186: $instance->singularResourceParameters($singular);
13187: }
13188: /**
13189: * Set the global resource parameter mapping.
13190: *
13191: * @param array $parameters
13192: * @return void
13193: * @static
13194: */
13195: public static function resourceParameters($parameters = [])
13196: {
13197: /** @var \Illuminate\Routing\Router $instance */
13198: $instance->resourceParameters($parameters);
13199: }
13200: /**
13201: * Get or set the verbs used in the resource URIs.
13202: *
13203: * @param array $verbs
13204: * @return array|null
13205: * @static
13206: */
13207: public static function resourceVerbs($verbs = [])
13208: {
13209: /** @var \Illuminate\Routing\Router $instance */
13210: return $instance->resourceVerbs($verbs);
13211: }
13212: /**
13213: * Get the underlying route collection.
13214: *
13215: * @return \Illuminate\Routing\RouteCollectionInterface
13216: * @static
13217: */
13218: public static function getRoutes()
13219: {
13220: /** @var \Illuminate\Routing\Router $instance */
13221: return $instance->getRoutes();
13222: }
13223: /**
13224: * Set the route collection instance.
13225: *
13226: * @param \Illuminate\Routing\RouteCollection $routes
13227: * @return void
13228: * @static
13229: */
13230: public static function setRoutes($routes)
13231: {
13232: /** @var \Illuminate\Routing\Router $instance */
13233: $instance->setRoutes($routes);
13234: }
13235: /**
13236: * Set the compiled route collection instance.
13237: *
13238: * @param array $routes
13239: * @return void
13240: * @static
13241: */
13242: public static function setCompiledRoutes($routes)
13243: {
13244: /** @var \Illuminate\Routing\Router $instance */
13245: $instance->setCompiledRoutes($routes);
13246: }
13247: /**
13248: * Remove any duplicate middleware from the given array.
13249: *
13250: * @param array $middleware
13251: * @return array
13252: * @static
13253: */
13254: public static function uniqueMiddleware($middleware)
13255: {
13256: return \Illuminate\Routing\Router::uniqueMiddleware($middleware);
13257: }
13258: /**
13259: * Set the container instance used by the router.
13260: *
13261: * @param \Illuminate\Container\Container $container
13262: * @return \Illuminate\Routing\Router
13263: * @static
13264: */
13265: public static function setContainer($container)
13266: {
13267: /** @var \Illuminate\Routing\Router $instance */
13268: return $instance->setContainer($container);
13269: }
13270: /**
13271: * Register a custom macro.
13272: *
13273: * @param string $name
13274: * @param object|callable $macro
13275: * @return void
13276: * @static
13277: */
13278: public static function macro($name, $macro)
13279: {
13280: \Illuminate\Routing\Router::macro($name, $macro);
13281: }
13282: /**
13283: * Mix another object into the class.
13284: *
13285: * @param object $mixin
13286: * @param bool $replace
13287: * @return void
13288: * @throws \ReflectionException
13289: * @static
13290: */
13291: public static function mixin($mixin, $replace = true)
13292: {
13293: \Illuminate\Routing\Router::mixin($mixin, $replace);
13294: }
13295: /**
13296: * Checks if macro is registered.
13297: *
13298: * @param string $name
13299: * @return bool
13300: * @static
13301: */
13302: public static function hasMacro($name)
13303: {
13304: return \Illuminate\Routing\Router::hasMacro($name);
13305: }
13306: /**
13307: * Flush the existing macros.
13308: *
13309: * @return void
13310: * @static
13311: */
13312: public static function flushMacros()
13313: {
13314: \Illuminate\Routing\Router::flushMacros();
13315: }
13316: /**
13317: * Dynamically handle calls to the class.
13318: *
13319: * @param string $method
13320: * @param array $parameters
13321: * @return mixed
13322: * @throws \BadMethodCallException
13323: * @static
13324: */
13325: public static function macroCall($method, $parameters)
13326: {
13327: /** @var \Illuminate\Routing\Router $instance */
13328: return $instance->macroCall($method, $parameters);
13329: }
13330:
13331: }
13332: /**
13333: *
13334: *
13335: * @see \Illuminate\Database\Schema\Builder
13336: */
13337: class Schema {
13338: /**
13339: * Create a database in the schema.
13340: *
13341: * @param string $name
13342: * @return bool
13343: * @static
13344: */
13345: public static function createDatabase($name)
13346: {
13347: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13348: return $instance->createDatabase($name);
13349: }
13350: /**
13351: * Drop a database from the schema if the database exists.
13352: *
13353: * @param string $name
13354: * @return bool
13355: * @static
13356: */
13357: public static function dropDatabaseIfExists($name)
13358: {
13359: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13360: return $instance->dropDatabaseIfExists($name);
13361: }
13362: /**
13363: * Determine if the given table exists.
13364: *
13365: * @param string $table
13366: * @return bool
13367: * @static
13368: */
13369: public static function hasTable($table)
13370: {
13371: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13372: return $instance->hasTable($table);
13373: }
13374: /**
13375: * Get the column listing for a given table.
13376: *
13377: * @param string $table
13378: * @return array
13379: * @static
13380: */
13381: public static function getColumnListing($table)
13382: {
13383: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13384: return $instance->getColumnListing($table);
13385: }
13386: /**
13387: * Drop all tables from the database.
13388: *
13389: * @return void
13390: * @static
13391: */
13392: public static function dropAllTables()
13393: {
13394: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13395: $instance->dropAllTables();
13396: }
13397: /**
13398: * Drop all views from the database.
13399: *
13400: * @return void
13401: * @static
13402: */
13403: public static function dropAllViews()
13404: {
13405: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13406: $instance->dropAllViews();
13407: }
13408: /**
13409: * Get all of the table names for the database.
13410: *
13411: * @return array
13412: * @static
13413: */
13414: public static function getAllTables()
13415: {
13416: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13417: return $instance->getAllTables();
13418: }
13419: /**
13420: * Get all of the view names for the database.
13421: *
13422: * @return array
13423: * @static
13424: */
13425: public static function getAllViews()
13426: {
13427: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13428: return $instance->getAllViews();
13429: }
13430: /**
13431: * Set the default string length for migrations.
13432: *
13433: * @param int $length
13434: * @return void
13435: * @static
13436: */
13437: public static function defaultStringLength($length)
13438: { //Method inherited from \Illuminate\Database\Schema\Builder
13439: \Illuminate\Database\Schema\MySqlBuilder::defaultStringLength($length);
13440: }
13441: /**
13442: * Set the default morph key type for migrations.
13443: *
13444: * @param string $type
13445: * @return void
13446: * @throws \InvalidArgumentException
13447: * @static
13448: */
13449: public static function defaultMorphKeyType($type)
13450: { //Method inherited from \Illuminate\Database\Schema\Builder
13451: \Illuminate\Database\Schema\MySqlBuilder::defaultMorphKeyType($type);
13452: }
13453: /**
13454: * Set the default morph key type for migrations to UUIDs.
13455: *
13456: * @return void
13457: * @static
13458: */
13459: public static function morphUsingUuids()
13460: { //Method inherited from \Illuminate\Database\Schema\Builder
13461: \Illuminate\Database\Schema\MySqlBuilder::morphUsingUuids();
13462: }
13463: /**
13464: * Determine if the given table has a given column.
13465: *
13466: * @param string $table
13467: * @param string $column
13468: * @return bool
13469: * @static
13470: */
13471: public static function hasColumn($table, $column)
13472: { //Method inherited from \Illuminate\Database\Schema\Builder
13473: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13474: return $instance->hasColumn($table, $column);
13475: }
13476: /**
13477: * Determine if the given table has given columns.
13478: *
13479: * @param string $table
13480: * @param array $columns
13481: * @return bool
13482: * @static
13483: */
13484: public static function hasColumns($table, $columns)
13485: { //Method inherited from \Illuminate\Database\Schema\Builder
13486: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13487: return $instance->hasColumns($table, $columns);
13488: }
13489: /**
13490: * Execute a table builder callback if the given table has a given column.
13491: *
13492: * @param string $table
13493: * @param string $column
13494: * @param \Closure $callback
13495: * @return void
13496: * @static
13497: */
13498: public static function whenTableHasColumn($table, $column, $callback)
13499: { //Method inherited from \Illuminate\Database\Schema\Builder
13500: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13501: $instance->whenTableHasColumn($table, $column, $callback);
13502: }
13503: /**
13504: * Execute a table builder callback if the given table doesn't have a given column.
13505: *
13506: * @param string $table
13507: * @param string $column
13508: * @param \Closure $callback
13509: * @return void
13510: * @static
13511: */
13512: public static function whenTableDoesntHaveColumn($table, $column, $callback)
13513: { //Method inherited from \Illuminate\Database\Schema\Builder
13514: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13515: $instance->whenTableDoesntHaveColumn($table, $column, $callback);
13516: }
13517: /**
13518: * Get the data type for the given column name.
13519: *
13520: * @param string $table
13521: * @param string $column
13522: * @return string
13523: * @static
13524: */
13525: public static function getColumnType($table, $column)
13526: { //Method inherited from \Illuminate\Database\Schema\Builder
13527: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13528: return $instance->getColumnType($table, $column);
13529: }
13530: /**
13531: * Modify a table on the schema.
13532: *
13533: * @param string $table
13534: * @param \Closure $callback
13535: * @return void
13536: * @static
13537: */
13538: public static function table($table, $callback)
13539: { //Method inherited from \Illuminate\Database\Schema\Builder
13540: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13541: $instance->table($table, $callback);
13542: }
13543: /**
13544: * Create a new table on the schema.
13545: *
13546: * @param string $table
13547: * @param \Closure $callback
13548: * @return void
13549: * @static
13550: */
13551: public static function create($table, $callback)
13552: { //Method inherited from \Illuminate\Database\Schema\Builder
13553: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13554: $instance->create($table, $callback);
13555: }
13556: /**
13557: * Drop a table from the schema.
13558: *
13559: * @param string $table
13560: * @return void
13561: * @static
13562: */
13563: public static function drop($table)
13564: { //Method inherited from \Illuminate\Database\Schema\Builder
13565: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13566: $instance->drop($table);
13567: }
13568: /**
13569: * Drop a table from the schema if it exists.
13570: *
13571: * @param string $table
13572: * @return void
13573: * @static
13574: */
13575: public static function dropIfExists($table)
13576: { //Method inherited from \Illuminate\Database\Schema\Builder
13577: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13578: $instance->dropIfExists($table);
13579: }
13580: /**
13581: * Drop columns from a table schema.
13582: *
13583: * @param string $table
13584: * @param string|array $columns
13585: * @return void
13586: * @static
13587: */
13588: public static function dropColumns($table, $columns)
13589: { //Method inherited from \Illuminate\Database\Schema\Builder
13590: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13591: $instance->dropColumns($table, $columns);
13592: }
13593: /**
13594: * Drop all types from the database.
13595: *
13596: * @return void
13597: * @throws \LogicException
13598: * @static
13599: */
13600: public static function dropAllTypes()
13601: { //Method inherited from \Illuminate\Database\Schema\Builder
13602: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13603: $instance->dropAllTypes();
13604: }
13605: /**
13606: * Rename a table on the schema.
13607: *
13608: * @param string $from
13609: * @param string $to
13610: * @return void
13611: * @static
13612: */
13613: public static function rename($from, $to)
13614: { //Method inherited from \Illuminate\Database\Schema\Builder
13615: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13616: $instance->rename($from, $to);
13617: }
13618: /**
13619: * Enable foreign key constraints.
13620: *
13621: * @return bool
13622: * @static
13623: */
13624: public static function enableForeignKeyConstraints()
13625: { //Method inherited from \Illuminate\Database\Schema\Builder
13626: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13627: return $instance->enableForeignKeyConstraints();
13628: }
13629: /**
13630: * Disable foreign key constraints.
13631: *
13632: * @return bool
13633: * @static
13634: */
13635: public static function disableForeignKeyConstraints()
13636: { //Method inherited from \Illuminate\Database\Schema\Builder
13637: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13638: return $instance->disableForeignKeyConstraints();
13639: }
13640: /**
13641: * Get the database connection instance.
13642: *
13643: * @return \Illuminate\Database\Connection
13644: * @static
13645: */
13646: public static function getConnection()
13647: { //Method inherited from \Illuminate\Database\Schema\Builder
13648: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13649: return $instance->getConnection();
13650: }
13651: /**
13652: * Set the database connection instance.
13653: *
13654: * @param \Illuminate\Database\Connection $connection
13655: * @return \Illuminate\Database\Schema\MySqlBuilder
13656: * @static
13657: */
13658: public static function setConnection($connection)
13659: { //Method inherited from \Illuminate\Database\Schema\Builder
13660: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13661: return $instance->setConnection($connection);
13662: }
13663: /**
13664: * Set the Schema Blueprint resolver callback.
13665: *
13666: * @param \Closure $resolver
13667: * @return void
13668: * @static
13669: */
13670: public static function blueprintResolver($resolver)
13671: { //Method inherited from \Illuminate\Database\Schema\Builder
13672: /** @var \Illuminate\Database\Schema\MySqlBuilder $instance */
13673: $instance->blueprintResolver($resolver);
13674: }
13675:
13676: }
13677: /**
13678: *
13679: *
13680: * @see \Illuminate\Session\SessionManager
13681: * @see \Illuminate\Session\Store
13682: */
13683: class Session {
13684: /**
13685: * Determine if requests for the same session should wait for each to finish before executing.
13686: *
13687: * @return bool
13688: * @static
13689: */
13690: public static function shouldBlock()
13691: {
13692: /** @var \Illuminate\Session\SessionManager $instance */
13693: return $instance->shouldBlock();
13694: }
13695: /**
13696: * Get the name of the cache store / driver that should be used to acquire session locks.
13697: *
13698: * @return string|null
13699: * @static
13700: */
13701: public static function blockDriver()
13702: {
13703: /** @var \Illuminate\Session\SessionManager $instance */
13704: return $instance->blockDriver();
13705: }
13706: /**
13707: * Get the session configuration.
13708: *
13709: * @return array
13710: * @static
13711: */
13712: public static function getSessionConfig()
13713: {
13714: /** @var \Illuminate\Session\SessionManager $instance */
13715: return $instance->getSessionConfig();
13716: }
13717: /**
13718: * Get the default session driver name.
13719: *
13720: * @return string
13721: * @static
13722: */
13723: public static function getDefaultDriver()
13724: {
13725: /** @var \Illuminate\Session\SessionManager $instance */
13726: return $instance->getDefaultDriver();
13727: }
13728: /**
13729: * Set the default session driver name.
13730: *
13731: * @param string $name
13732: * @return void
13733: * @static
13734: */
13735: public static function setDefaultDriver($name)
13736: {
13737: /** @var \Illuminate\Session\SessionManager $instance */
13738: $instance->setDefaultDriver($name);
13739: }
13740: /**
13741: * Get a driver instance.
13742: *
13743: * @param string|null $driver
13744: * @return mixed
13745: * @throws \InvalidArgumentException
13746: * @static
13747: */
13748: public static function driver($driver = null)
13749: { //Method inherited from \Illuminate\Support\Manager
13750: /** @var \Illuminate\Session\SessionManager $instance */
13751: return $instance->driver($driver);
13752: }
13753: /**
13754: * Register a custom driver creator Closure.
13755: *
13756: * @param string $driver
13757: * @param \Closure $callback
13758: * @return \Illuminate\Session\SessionManager
13759: * @static
13760: */
13761: public static function extend($driver, $callback)
13762: { //Method inherited from \Illuminate\Support\Manager
13763: /** @var \Illuminate\Session\SessionManager $instance */
13764: return $instance->extend($driver, $callback);
13765: }
13766: /**
13767: * Get all of the created "drivers".
13768: *
13769: * @return array
13770: * @static
13771: */
13772: public static function getDrivers()
13773: { //Method inherited from \Illuminate\Support\Manager
13774: /** @var \Illuminate\Session\SessionManager $instance */
13775: return $instance->getDrivers();
13776: }
13777: /**
13778: * Get the container instance used by the manager.
13779: *
13780: * @return \Illuminate\Contracts\Container\Container
13781: * @static
13782: */
13783: public static function getContainer()
13784: { //Method inherited from \Illuminate\Support\Manager
13785: /** @var \Illuminate\Session\SessionManager $instance */
13786: return $instance->getContainer();
13787: }
13788: /**
13789: * Set the container instance used by the manager.
13790: *
13791: * @param \Illuminate\Contracts\Container\Container $container
13792: * @return \Illuminate\Session\SessionManager
13793: * @static
13794: */
13795: public static function setContainer($container)
13796: { //Method inherited from \Illuminate\Support\Manager
13797: /** @var \Illuminate\Session\SessionManager $instance */
13798: return $instance->setContainer($container);
13799: }
13800: /**
13801: * Forget all of the resolved driver instances.
13802: *
13803: * @return \Illuminate\Session\SessionManager
13804: * @static
13805: */
13806: public static function forgetDrivers()
13807: { //Method inherited from \Illuminate\Support\Manager
13808: /** @var \Illuminate\Session\SessionManager $instance */
13809: return $instance->forgetDrivers();
13810: }
13811: /**
13812: * Start the session, reading the data from a handler.
13813: *
13814: * @return bool
13815: * @static
13816: */
13817: public static function start()
13818: {
13819: /** @var \Illuminate\Session\Store $instance */
13820: return $instance->start();
13821: }
13822: /**
13823: * Save the session data to storage.
13824: *
13825: * @return void
13826: * @static
13827: */
13828: public static function save()
13829: {
13830: /** @var \Illuminate\Session\Store $instance */
13831: $instance->save();
13832: }
13833: /**
13834: * Age the flash data for the session.
13835: *
13836: * @return void
13837: * @static
13838: */
13839: public static function ageFlashData()
13840: {
13841: /** @var \Illuminate\Session\Store $instance */
13842: $instance->ageFlashData();
13843: }
13844: /**
13845: * Get all of the session data.
13846: *
13847: * @return array
13848: * @static
13849: */
13850: public static function all()
13851: {
13852: /** @var \Illuminate\Session\Store $instance */
13853: return $instance->all();
13854: }
13855: /**
13856: * Get a subset of the session data.
13857: *
13858: * @param array $keys
13859: * @return array
13860: * @static
13861: */
13862: public static function only($keys)
13863: {
13864: /** @var \Illuminate\Session\Store $instance */
13865: return $instance->only($keys);
13866: }
13867: /**
13868: * Checks if a key exists.
13869: *
13870: * @param string|array $key
13871: * @return bool
13872: * @static
13873: */
13874: public static function exists($key)
13875: {
13876: /** @var \Illuminate\Session\Store $instance */
13877: return $instance->exists($key);
13878: }
13879: /**
13880: * Determine if the given key is missing from the session data.
13881: *
13882: * @param string|array $key
13883: * @return bool
13884: * @static
13885: */
13886: public static function missing($key)
13887: {
13888: /** @var \Illuminate\Session\Store $instance */
13889: return $instance->missing($key);
13890: }
13891: /**
13892: * Checks if a key is present and not null.
13893: *
13894: * @param string|array $key
13895: * @return bool
13896: * @static
13897: */
13898: public static function has($key)
13899: {
13900: /** @var \Illuminate\Session\Store $instance */
13901: return $instance->has($key);
13902: }
13903: /**
13904: * Get an item from the session.
13905: *
13906: * @param string $key
13907: * @param mixed $default
13908: * @return mixed
13909: * @static
13910: */
13911: public static function get($key, $default = null)
13912: {
13913: /** @var \Illuminate\Session\Store $instance */
13914: return $instance->get($key, $default);
13915: }
13916: /**
13917: * Get the value of a given key and then forget it.
13918: *
13919: * @param string $key
13920: * @param mixed $default
13921: * @return mixed
13922: * @static
13923: */
13924: public static function pull($key, $default = null)
13925: {
13926: /** @var \Illuminate\Session\Store $instance */
13927: return $instance->pull($key, $default);
13928: }
13929: /**
13930: * Determine if the session contains old input.
13931: *
13932: * @param string|null $key
13933: * @return bool
13934: * @static
13935: */
13936: public static function hasOldInput($key = null)
13937: {
13938: /** @var \Illuminate\Session\Store $instance */
13939: return $instance->hasOldInput($key);
13940: }
13941: /**
13942: * Get the requested item from the flashed input array.
13943: *
13944: * @param string|null $key
13945: * @param mixed $default
13946: * @return mixed
13947: * @static
13948: */
13949: public static function getOldInput($key = null, $default = null)
13950: {
13951: /** @var \Illuminate\Session\Store $instance */
13952: return $instance->getOldInput($key, $default);
13953: }
13954: /**
13955: * Replace the given session attributes entirely.
13956: *
13957: * @param array $attributes
13958: * @return void
13959: * @static
13960: */
13961: public static function replace($attributes)
13962: {
13963: /** @var \Illuminate\Session\Store $instance */
13964: $instance->replace($attributes);
13965: }
13966: /**
13967: * Put a key / value pair or array of key / value pairs in the session.
13968: *
13969: * @param string|array $key
13970: * @param mixed $value
13971: * @return void
13972: * @static
13973: */
13974: public static function put($key, $value = null)
13975: {
13976: /** @var \Illuminate\Session\Store $instance */
13977: $instance->put($key, $value);
13978: }
13979: /**
13980: * Get an item from the session, or store the default value.
13981: *
13982: * @param string $key
13983: * @param \Closure $callback
13984: * @return mixed
13985: * @static
13986: */
13987: public static function remember($key, $callback)
13988: {
13989: /** @var \Illuminate\Session\Store $instance */
13990: return $instance->remember($key, $callback);
13991: }
13992: /**
13993: * Push a value onto a session array.
13994: *
13995: * @param string $key
13996: * @param mixed $value
13997: * @return void
13998: * @static
13999: */
14000: public static function push($key, $value)
14001: {
14002: /** @var \Illuminate\Session\Store $instance */
14003: $instance->push($key, $value);
14004: }
14005: /**
14006: * Increment the value of an item in the session.
14007: *
14008: * @param string $key
14009: * @param int $amount
14010: * @return mixed
14011: * @static
14012: */
14013: public static function increment($key, $amount = 1)
14014: {
14015: /** @var \Illuminate\Session\Store $instance */
14016: return $instance->increment($key, $amount);
14017: }
14018: /**
14019: * Decrement the value of an item in the session.
14020: *
14021: * @param string $key
14022: * @param int $amount
14023: * @return int
14024: * @static
14025: */
14026: public static function decrement($key, $amount = 1)
14027: {
14028: /** @var \Illuminate\Session\Store $instance */
14029: return $instance->decrement($key, $amount);
14030: }
14031: /**
14032: * Flash a key / value pair to the session.
14033: *
14034: * @param string $key
14035: * @param mixed $value
14036: * @return void
14037: * @static
14038: */
14039: public static function flash($key, $value = true)
14040: {
14041: /** @var \Illuminate\Session\Store $instance */
14042: $instance->flash($key, $value);
14043: }
14044: /**
14045: * Flash a key / value pair to the session for immediate use.
14046: *
14047: * @param string $key
14048: * @param mixed $value
14049: * @return void
14050: * @static
14051: */
14052: public static function now($key, $value)
14053: {
14054: /** @var \Illuminate\Session\Store $instance */
14055: $instance->now($key, $value);
14056: }
14057: /**
14058: * Reflash all of the session flash data.
14059: *
14060: * @return void
14061: * @static
14062: */
14063: public static function reflash()
14064: {
14065: /** @var \Illuminate\Session\Store $instance */
14066: $instance->reflash();
14067: }
14068: /**
14069: * Reflash a subset of the current flash data.
14070: *
14071: * @param array|mixed $keys
14072: * @return void
14073: * @static
14074: */
14075: public static function keep($keys = null)
14076: {
14077: /** @var \Illuminate\Session\Store $instance */
14078: $instance->keep($keys);
14079: }
14080: /**
14081: * Flash an input array to the session.
14082: *
14083: * @param array $value
14084: * @return void
14085: * @static
14086: */
14087: public static function flashInput($value)
14088: {
14089: /** @var \Illuminate\Session\Store $instance */
14090: $instance->flashInput($value);
14091: }
14092: /**
14093: * Remove an item from the session, returning its value.
14094: *
14095: * @param string $key
14096: * @return mixed
14097: * @static
14098: */
14099: public static function remove($key)
14100: {
14101: /** @var \Illuminate\Session\Store $instance */
14102: return $instance->remove($key);
14103: }
14104: /**
14105: * Remove one or many items from the session.
14106: *
14107: * @param string|array $keys
14108: * @return void
14109: * @static
14110: */
14111: public static function forget($keys)
14112: {
14113: /** @var \Illuminate\Session\Store $instance */
14114: $instance->forget($keys);
14115: }
14116: /**
14117: * Remove all of the items from the session.
14118: *
14119: * @return void
14120: * @static
14121: */
14122: public static function flush()
14123: {
14124: /** @var \Illuminate\Session\Store $instance */
14125: $instance->flush();
14126: }
14127: /**
14128: * Flush the session data and regenerate the ID.
14129: *
14130: * @return bool
14131: * @static
14132: */
14133: public static function invalidate()
14134: {
14135: /** @var \Illuminate\Session\Store $instance */
14136: return $instance->invalidate();
14137: }
14138: /**
14139: * Generate a new session identifier.
14140: *
14141: * @param bool $destroy
14142: * @return bool
14143: * @static
14144: */
14145: public static function regenerate($destroy = false)
14146: {
14147: /** @var \Illuminate\Session\Store $instance */
14148: return $instance->regenerate($destroy);
14149: }
14150: /**
14151: * Generate a new session ID for the session.
14152: *
14153: * @param bool $destroy
14154: * @return bool
14155: * @static
14156: */
14157: public static function migrate($destroy = false)
14158: {
14159: /** @var \Illuminate\Session\Store $instance */
14160: return $instance->migrate($destroy);
14161: }
14162: /**
14163: * Determine if the session has been started.
14164: *
14165: * @return bool
14166: * @static
14167: */
14168: public static function isStarted()
14169: {
14170: /** @var \Illuminate\Session\Store $instance */
14171: return $instance->isStarted();
14172: }
14173: /**
14174: * Get the name of the session.
14175: *
14176: * @return string
14177: * @static
14178: */
14179: public static function getName()
14180: {
14181: /** @var \Illuminate\Session\Store $instance */
14182: return $instance->getName();
14183: }
14184: /**
14185: * Set the name of the session.
14186: *
14187: * @param string $name
14188: * @return void
14189: * @static
14190: */
14191: public static function setName($name)
14192: {
14193: /** @var \Illuminate\Session\Store $instance */
14194: $instance->setName($name);
14195: }
14196: /**
14197: * Get the current session ID.
14198: *
14199: * @return string
14200: * @static
14201: */
14202: public static function getId()
14203: {
14204: /** @var \Illuminate\Session\Store $instance */
14205: return $instance->getId();
14206: }
14207: /**
14208: * Set the session ID.
14209: *
14210: * @param string $id
14211: * @return void
14212: * @static
14213: */
14214: public static function setId($id)
14215: {
14216: /** @var \Illuminate\Session\Store $instance */
14217: $instance->setId($id);
14218: }
14219: /**
14220: * Determine if this is a valid session ID.
14221: *
14222: * @param string $id
14223: * @return bool
14224: * @static
14225: */
14226: public static function isValidId($id)
14227: {
14228: /** @var \Illuminate\Session\Store $instance */
14229: return $instance->isValidId($id);
14230: }
14231: /**
14232: * Set the existence of the session on the handler if applicable.
14233: *
14234: * @param bool $value
14235: * @return void
14236: * @static
14237: */
14238: public static function setExists($value)
14239: {
14240: /** @var \Illuminate\Session\Store $instance */
14241: $instance->setExists($value);
14242: }
14243: /**
14244: * Get the CSRF token value.
14245: *
14246: * @return string
14247: * @static
14248: */
14249: public static function token()
14250: {
14251: /** @var \Illuminate\Session\Store $instance */
14252: return $instance->token();
14253: }
14254: /**
14255: * Regenerate the CSRF token value.
14256: *
14257: * @return void
14258: * @static
14259: */
14260: public static function regenerateToken()
14261: {
14262: /** @var \Illuminate\Session\Store $instance */
14263: $instance->regenerateToken();
14264: }
14265: /**
14266: * Get the previous URL from the session.
14267: *
14268: * @return string|null
14269: * @static
14270: */
14271: public static function previousUrl()
14272: {
14273: /** @var \Illuminate\Session\Store $instance */
14274: return $instance->previousUrl();
14275: }
14276: /**
14277: * Set the "previous" URL in the session.
14278: *
14279: * @param string $url
14280: * @return void
14281: * @static
14282: */
14283: public static function setPreviousUrl($url)
14284: {
14285: /** @var \Illuminate\Session\Store $instance */
14286: $instance->setPreviousUrl($url);
14287: }
14288: /**
14289: * Specify that the user has confirmed their password.
14290: *
14291: * @return void
14292: * @static
14293: */
14294: public static function passwordConfirmed()
14295: {
14296: /** @var \Illuminate\Session\Store $instance */
14297: $instance->passwordConfirmed();
14298: }
14299: /**
14300: * Get the underlying session handler implementation.
14301: *
14302: * @return \SessionHandlerInterface
14303: * @static
14304: */
14305: public static function getHandler()
14306: {
14307: /** @var \Illuminate\Session\Store $instance */
14308: return $instance->getHandler();
14309: }
14310: /**
14311: * Determine if the session handler needs a request.
14312: *
14313: * @return bool
14314: * @static
14315: */
14316: public static function handlerNeedsRequest()
14317: {
14318: /** @var \Illuminate\Session\Store $instance */
14319: return $instance->handlerNeedsRequest();
14320: }
14321: /**
14322: * Set the request on the handler instance.
14323: *
14324: * @param \Illuminate\Http\Request $request
14325: * @return void
14326: * @static
14327: */
14328: public static function setRequestOnHandler($request)
14329: {
14330: /** @var \Illuminate\Session\Store $instance */
14331: $instance->setRequestOnHandler($request);
14332: }
14333:
14334: }
14335: /**
14336: *
14337: *
14338: * @see \Illuminate\Filesystem\FilesystemManager
14339: */
14340: class Storage {
14341: /**
14342: * Get a filesystem instance.
14343: *
14344: * @param string|null $name
14345: * @return \Illuminate\Filesystem\FilesystemAdapter
14346: * @static
14347: */
14348: public static function drive($name = null)
14349: {
14350: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14351: return $instance->drive($name);
14352: }
14353: /**
14354: * Get a filesystem instance.
14355: *
14356: * @param string|null $name
14357: * @return \Illuminate\Filesystem\FilesystemAdapter
14358: * @static
14359: */
14360: public static function disk($name = null)
14361: {
14362: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14363: return $instance->disk($name);
14364: }
14365: /**
14366: * Get a default cloud filesystem instance.
14367: *
14368: * @return \Illuminate\Filesystem\FilesystemAdapter
14369: * @static
14370: */
14371: public static function cloud()
14372: {
14373: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14374: return $instance->cloud();
14375: }
14376: /**
14377: * Build an on-demand disk.
14378: *
14379: * @param string|array $config
14380: * @return \Illuminate\Filesystem\FilesystemAdapter
14381: * @static
14382: */
14383: public static function build($config)
14384: {
14385: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14386: return $instance->build($config);
14387: }
14388: /**
14389: * Create an instance of the local driver.
14390: *
14391: * @param array $config
14392: * @return \Illuminate\Filesystem\FilesystemAdapter
14393: * @static
14394: */
14395: public static function createLocalDriver($config)
14396: {
14397: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14398: return $instance->createLocalDriver($config);
14399: }
14400: /**
14401: * Create an instance of the ftp driver.
14402: *
14403: * @param array $config
14404: * @return \Illuminate\Filesystem\FilesystemAdapter
14405: * @static
14406: */
14407: public static function createFtpDriver($config)
14408: {
14409: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14410: return $instance->createFtpDriver($config);
14411: }
14412: /**
14413: * Create an instance of the sftp driver.
14414: *
14415: * @param array $config
14416: * @return \Illuminate\Filesystem\FilesystemAdapter
14417: * @static
14418: */
14419: public static function createSftpDriver($config)
14420: {
14421: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14422: return $instance->createSftpDriver($config);
14423: }
14424: /**
14425: * Create an instance of the Amazon S3 driver.
14426: *
14427: * @param array $config
14428: * @return \Illuminate\Contracts\Filesystem\Cloud
14429: * @static
14430: */
14431: public static function createS3Driver($config)
14432: {
14433: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14434: return $instance->createS3Driver($config);
14435: }
14436: /**
14437: * Set the given disk instance.
14438: *
14439: * @param string $name
14440: * @param mixed $disk
14441: * @return \Illuminate\Filesystem\FilesystemManager
14442: * @static
14443: */
14444: public static function set($name, $disk)
14445: {
14446: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14447: return $instance->set($name, $disk);
14448: }
14449: /**
14450: * Get the default driver name.
14451: *
14452: * @return string
14453: * @static
14454: */
14455: public static function getDefaultDriver()
14456: {
14457: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14458: return $instance->getDefaultDriver();
14459: }
14460: /**
14461: * Get the default cloud driver name.
14462: *
14463: * @return string
14464: * @static
14465: */
14466: public static function getDefaultCloudDriver()
14467: {
14468: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14469: return $instance->getDefaultCloudDriver();
14470: }
14471: /**
14472: * Unset the given disk instances.
14473: *
14474: * @param array|string $disk
14475: * @return \Illuminate\Filesystem\FilesystemManager
14476: * @static
14477: */
14478: public static function forgetDisk($disk)
14479: {
14480: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14481: return $instance->forgetDisk($disk);
14482: }
14483: /**
14484: * Disconnect the given disk and remove from local cache.
14485: *
14486: * @param string|null $name
14487: * @return void
14488: * @static
14489: */
14490: public static function purge($name = null)
14491: {
14492: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14493: $instance->purge($name);
14494: }
14495: /**
14496: * Register a custom driver creator Closure.
14497: *
14498: * @param string $driver
14499: * @param \Closure $callback
14500: * @return \Illuminate\Filesystem\FilesystemManager
14501: * @static
14502: */
14503: public static function extend($driver, $callback)
14504: {
14505: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14506: return $instance->extend($driver, $callback);
14507: }
14508: /**
14509: * Set the application instance used by the manager.
14510: *
14511: * @param \Illuminate\Contracts\Foundation\Application $app
14512: * @return \Illuminate\Filesystem\FilesystemManager
14513: * @static
14514: */
14515: public static function setApplication($app)
14516: {
14517: /** @var \Illuminate\Filesystem\FilesystemManager $instance */
14518: return $instance->setApplication($app);
14519: }
14520: /**
14521: * Assert that the given file or directory exists.
14522: *
14523: * @param string|array $path
14524: * @param string|null $content
14525: * @return \Illuminate\Filesystem\FilesystemAdapter
14526: * @static
14527: */
14528: public static function assertExists($path, $content = null)
14529: {
14530: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14531: return $instance->assertExists($path, $content);
14532: }
14533: /**
14534: * Assert that the given file or directory does not exist.
14535: *
14536: * @param string|array $path
14537: * @return \Illuminate\Filesystem\FilesystemAdapter
14538: * @static
14539: */
14540: public static function assertMissing($path)
14541: {
14542: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14543: return $instance->assertMissing($path);
14544: }
14545: /**
14546: * Assert that the given directory is empty.
14547: *
14548: * @param string $path
14549: * @return \Illuminate\Filesystem\FilesystemAdapter
14550: * @static
14551: */
14552: public static function assertDirectoryEmpty($path)
14553: {
14554: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14555: return $instance->assertDirectoryEmpty($path);
14556: }
14557: /**
14558: * Determine if a file or directory exists.
14559: *
14560: * @param string $path
14561: * @return bool
14562: * @static
14563: */
14564: public static function exists($path)
14565: {
14566: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14567: return $instance->exists($path);
14568: }
14569: /**
14570: * Determine if a file or directory is missing.
14571: *
14572: * @param string $path
14573: * @return bool
14574: * @static
14575: */
14576: public static function missing($path)
14577: {
14578: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14579: return $instance->missing($path);
14580: }
14581: /**
14582: * Determine if a file exists.
14583: *
14584: * @param string $path
14585: * @return bool
14586: * @static
14587: */
14588: public static function fileExists($path)
14589: {
14590: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14591: return $instance->fileExists($path);
14592: }
14593: /**
14594: * Determine if a file is missing.
14595: *
14596: * @param string $path
14597: * @return bool
14598: * @static
14599: */
14600: public static function fileMissing($path)
14601: {
14602: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14603: return $instance->fileMissing($path);
14604: }
14605: /**
14606: * Determine if a directory exists.
14607: *
14608: * @param string $path
14609: * @return bool
14610: * @static
14611: */
14612: public static function directoryExists($path)
14613: {
14614: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14615: return $instance->directoryExists($path);
14616: }
14617: /**
14618: * Determine if a directory is missing.
14619: *
14620: * @param string $path
14621: * @return bool
14622: * @static
14623: */
14624: public static function directoryMissing($path)
14625: {
14626: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14627: return $instance->directoryMissing($path);
14628: }
14629: /**
14630: * Get the full path for the file at the given "short" path.
14631: *
14632: * @param string $path
14633: * @return string
14634: * @static
14635: */
14636: public static function path($path)
14637: {
14638: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14639: return $instance->path($path);
14640: }
14641: /**
14642: * Get the contents of a file.
14643: *
14644: * @param string $path
14645: * @return string|null
14646: * @static
14647: */
14648: public static function get($path)
14649: {
14650: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14651: return $instance->get($path);
14652: }
14653: /**
14654: * Create a streamed response for a given file.
14655: *
14656: * @param string $path
14657: * @param string|null $name
14658: * @param array $headers
14659: * @param string|null $disposition
14660: * @return \Symfony\Component\HttpFoundation\StreamedResponse
14661: * @static
14662: */
14663: public static function response($path, $name = null, $headers = [], $disposition = 'inline')
14664: {
14665: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14666: return $instance->response($path, $name, $headers, $disposition);
14667: }
14668: /**
14669: * Create a streamed download response for a given file.
14670: *
14671: * @param string $path
14672: * @param string|null $name
14673: * @return \Symfony\Component\HttpFoundation\StreamedResponse
14674: * @static
14675: */
14676: public static function download($path, $name = null, $headers = [])
14677: {
14678: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14679: return $instance->download($path, $name, $headers);
14680: }
14681: /**
14682: * Write the contents of a file.
14683: *
14684: * @param string $path
14685: * @param \Psr\Http\Message\StreamInterface|\Illuminate\Http\File|\Illuminate\Http\UploadedFile|string|resource $contents
14686: * @param mixed $options
14687: * @return string|bool
14688: * @static
14689: */
14690: public static function put($path, $contents, $options = [])
14691: {
14692: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14693: return $instance->put($path, $contents, $options);
14694: }
14695: /**
14696: * Store the uploaded file on the disk.
14697: *
14698: * @param string $path
14699: * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file
14700: * @param mixed $options
14701: * @return string|false
14702: * @static
14703: */
14704: public static function putFile($path, $file, $options = [])
14705: {
14706: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14707: return $instance->putFile($path, $file, $options);
14708: }
14709: /**
14710: * Store the uploaded file on the disk with a given name.
14711: *
14712: * @param string $path
14713: * @param \Illuminate\Http\File|\Illuminate\Http\UploadedFile|string $file
14714: * @param string $name
14715: * @param mixed $options
14716: * @return string|false
14717: * @static
14718: */
14719: public static function putFileAs($path, $file, $name, $options = [])
14720: {
14721: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14722: return $instance->putFileAs($path, $file, $name, $options);
14723: }
14724: /**
14725: * Get the visibility for the given path.
14726: *
14727: * @param string $path
14728: * @return string
14729: * @static
14730: */
14731: public static function getVisibility($path)
14732: {
14733: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14734: return $instance->getVisibility($path);
14735: }
14736: /**
14737: * Set the visibility for the given path.
14738: *
14739: * @param string $path
14740: * @param string $visibility
14741: * @return bool
14742: * @static
14743: */
14744: public static function setVisibility($path, $visibility)
14745: {
14746: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14747: return $instance->setVisibility($path, $visibility);
14748: }
14749: /**
14750: * Prepend to a file.
14751: *
14752: * @param string $path
14753: * @param string $data
14754: * @param string $separator
14755: * @return bool
14756: * @static
14757: */
14758: public static function prepend($path, $data, $separator = '
14759: ')
14760: {
14761: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14762: return $instance->prepend($path, $data, $separator);
14763: }
14764: /**
14765: * Append to a file.
14766: *
14767: * @param string $path
14768: * @param string $data
14769: * @param string $separator
14770: * @return bool
14771: * @static
14772: */
14773: public static function append($path, $data, $separator = '
14774: ')
14775: {
14776: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14777: return $instance->append($path, $data, $separator);
14778: }
14779: /**
14780: * Delete the file at a given path.
14781: *
14782: * @param string|array $paths
14783: * @return bool
14784: * @static
14785: */
14786: public static function delete($paths)
14787: {
14788: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14789: return $instance->delete($paths);
14790: }
14791: /**
14792: * Copy a file to a new location.
14793: *
14794: * @param string $from
14795: * @param string $to
14796: * @return bool
14797: * @static
14798: */
14799: public static function copy($from, $to)
14800: {
14801: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14802: return $instance->copy($from, $to);
14803: }
14804: /**
14805: * Move a file to a new location.
14806: *
14807: * @param string $from
14808: * @param string $to
14809: * @return bool
14810: * @static
14811: */
14812: public static function move($from, $to)
14813: {
14814: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14815: return $instance->move($from, $to);
14816: }
14817: /**
14818: * Get the file size of a given file.
14819: *
14820: * @param string $path
14821: * @return int
14822: * @static
14823: */
14824: public static function size($path)
14825: {
14826: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14827: return $instance->size($path);
14828: }
14829: /**
14830: * Get the mime-type of a given file.
14831: *
14832: * @param string $path
14833: * @return string|false
14834: * @static
14835: */
14836: public static function mimeType($path)
14837: {
14838: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14839: return $instance->mimeType($path);
14840: }
14841: /**
14842: * Get the file's last modification time.
14843: *
14844: * @param string $path
14845: * @return int
14846: * @static
14847: */
14848: public static function lastModified($path)
14849: {
14850: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14851: return $instance->lastModified($path);
14852: }
14853: /**
14854: * Get a resource to read the file.
14855: *
14856: * @param string $path
14857: * @return resource|null The path resource or null on failure.
14858: * @static
14859: */
14860: public static function readStream($path)
14861: {
14862: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14863: return $instance->readStream($path);
14864: }
14865: /**
14866: * Write a new file using a stream.
14867: *
14868: * @param string $path
14869: * @param resource $resource
14870: * @param array $options
14871: * @return bool
14872: * @static
14873: */
14874: public static function writeStream($path, $resource, $options = [])
14875: {
14876: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14877: return $instance->writeStream($path, $resource, $options);
14878: }
14879: /**
14880: * Get the URL for the file at the given path.
14881: *
14882: * @param string $path
14883: * @return string
14884: * @throws \RuntimeException
14885: * @static
14886: */
14887: public static function url($path)
14888: {
14889: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14890: return $instance->url($path);
14891: }
14892: /**
14893: * Get a temporary URL for the file at the given path.
14894: *
14895: * @param string $path
14896: * @param \DateTimeInterface $expiration
14897: * @param array $options
14898: * @return string
14899: * @throws \RuntimeException
14900: * @static
14901: */
14902: public static function temporaryUrl($path, $expiration, $options = [])
14903: {
14904: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14905: return $instance->temporaryUrl($path, $expiration, $options);
14906: }
14907: /**
14908: * Get an array of all files in a directory.
14909: *
14910: * @param string|null $directory
14911: * @param bool $recursive
14912: * @return array
14913: * @static
14914: */
14915: public static function files($directory = null, $recursive = false)
14916: {
14917: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14918: return $instance->files($directory, $recursive);
14919: }
14920: /**
14921: * Get all of the files from the given directory (recursive).
14922: *
14923: * @param string|null $directory
14924: * @return array
14925: * @static
14926: */
14927: public static function allFiles($directory = null)
14928: {
14929: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14930: return $instance->allFiles($directory);
14931: }
14932: /**
14933: * Get all of the directories within a given directory.
14934: *
14935: * @param string|null $directory
14936: * @param bool $recursive
14937: * @return array
14938: * @static
14939: */
14940: public static function directories($directory = null, $recursive = false)
14941: {
14942: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14943: return $instance->directories($directory, $recursive);
14944: }
14945: /**
14946: * Get all the directories within a given directory (recursive).
14947: *
14948: * @param string|null $directory
14949: * @return array
14950: * @static
14951: */
14952: public static function allDirectories($directory = null)
14953: {
14954: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14955: return $instance->allDirectories($directory);
14956: }
14957: /**
14958: * Create a directory.
14959: *
14960: * @param string $path
14961: * @return bool
14962: * @static
14963: */
14964: public static function makeDirectory($path)
14965: {
14966: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14967: return $instance->makeDirectory($path);
14968: }
14969: /**
14970: * Recursively delete a directory.
14971: *
14972: * @param string $directory
14973: * @return bool
14974: * @static
14975: */
14976: public static function deleteDirectory($directory)
14977: {
14978: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14979: return $instance->deleteDirectory($directory);
14980: }
14981: /**
14982: * Get the Flysystem driver.
14983: *
14984: * @return \League\Flysystem\FilesystemOperator
14985: * @static
14986: */
14987: public static function getDriver()
14988: {
14989: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
14990: return $instance->getDriver();
14991: }
14992: /**
14993: * Get the Flysystem adapter.
14994: *
14995: * @return \League\Flysystem\FilesystemAdapter
14996: * @static
14997: */
14998: public static function getAdapter()
14999: {
15000: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15001: return $instance->getAdapter();
15002: }
15003: /**
15004: * Get the configuration values.
15005: *
15006: * @return array
15007: * @static
15008: */
15009: public static function getConfig()
15010: {
15011: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15012: return $instance->getConfig();
15013: }
15014: /**
15015: * Define a custom temporary URL builder callback.
15016: *
15017: * @param \Closure $callback
15018: * @return void
15019: * @static
15020: */
15021: public static function buildTemporaryUrlsUsing($callback)
15022: {
15023: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15024: $instance->buildTemporaryUrlsUsing($callback);
15025: }
15026: /**
15027: * Register a custom macro.
15028: *
15029: * @param string $name
15030: * @param object|callable $macro
15031: * @return void
15032: * @static
15033: */
15034: public static function macro($name, $macro)
15035: {
15036: \Illuminate\Filesystem\FilesystemAdapter::macro($name, $macro);
15037: }
15038: /**
15039: * Mix another object into the class.
15040: *
15041: * @param object $mixin
15042: * @param bool $replace
15043: * @return void
15044: * @throws \ReflectionException
15045: * @static
15046: */
15047: public static function mixin($mixin, $replace = true)
15048: {
15049: \Illuminate\Filesystem\FilesystemAdapter::mixin($mixin, $replace);
15050: }
15051: /**
15052: * Checks if macro is registered.
15053: *
15054: * @param string $name
15055: * @return bool
15056: * @static
15057: */
15058: public static function hasMacro($name)
15059: {
15060: return \Illuminate\Filesystem\FilesystemAdapter::hasMacro($name);
15061: }
15062: /**
15063: * Flush the existing macros.
15064: *
15065: * @return void
15066: * @static
15067: */
15068: public static function flushMacros()
15069: {
15070: \Illuminate\Filesystem\FilesystemAdapter::flushMacros();
15071: }
15072: /**
15073: * Dynamically handle calls to the class.
15074: *
15075: * @param string $method
15076: * @param array $parameters
15077: * @return mixed
15078: * @throws \BadMethodCallException
15079: * @static
15080: */
15081: public static function macroCall($method, $parameters)
15082: {
15083: /** @var \Illuminate\Filesystem\FilesystemAdapter $instance */
15084: return $instance->macroCall($method, $parameters);
15085: }
15086:
15087: }
15088: /**
15089: *
15090: *
15091: * @see \Illuminate\Routing\UrlGenerator
15092: */
15093: class URL {
15094: /**
15095: * Get the full URL for the current request.
15096: *
15097: * @return string
15098: * @static
15099: */
15100: public static function full()
15101: {
15102: /** @var \Illuminate\Routing\UrlGenerator $instance */
15103: return $instance->full();
15104: }
15105: /**
15106: * Get the current URL for the request.
15107: *
15108: * @return string
15109: * @static
15110: */
15111: public static function current()
15112: {
15113: /** @var \Illuminate\Routing\UrlGenerator $instance */
15114: return $instance->current();
15115: }
15116: /**
15117: * Get the URL for the previous request.
15118: *
15119: * @param mixed $fallback
15120: * @return string
15121: * @static
15122: */
15123: public static function previous($fallback = false)
15124: {
15125: /** @var \Illuminate\Routing\UrlGenerator $instance */
15126: return $instance->previous($fallback);
15127: }
15128: /**
15129: * Get the previous path info for the request.
15130: *
15131: * @param mixed $fallback
15132: * @return string
15133: * @static
15134: */
15135: public static function previousPath($fallback = false)
15136: {
15137: /** @var \Illuminate\Routing\UrlGenerator $instance */
15138: return $instance->previousPath($fallback);
15139: }
15140: /**
15141: * Generate an absolute URL to the given path.
15142: *
15143: * @param string $path
15144: * @param mixed $extra
15145: * @param bool|null $secure
15146: * @return string
15147: * @static
15148: */
15149: public static function to($path, $extra = [], $secure = null)
15150: {
15151: /** @var \Illuminate\Routing\UrlGenerator $instance */
15152: return $instance->to($path, $extra, $secure);
15153: }
15154: /**
15155: * Generate a secure, absolute URL to the given path.
15156: *
15157: * @param string $path
15158: * @param array $parameters
15159: * @return string
15160: * @static
15161: */
15162: public static function secure($path, $parameters = [])
15163: {
15164: /** @var \Illuminate\Routing\UrlGenerator $instance */
15165: return $instance->secure($path, $parameters);
15166: }
15167: /**
15168: * Generate the URL to an application asset.
15169: *
15170: * @param string $path
15171: * @param bool|null $secure
15172: * @return string
15173: * @static
15174: */
15175: public static function asset($path, $secure = null)
15176: {
15177: /** @var \Illuminate\Routing\UrlGenerator $instance */
15178: return $instance->asset($path, $secure);
15179: }
15180: /**
15181: * Generate the URL to a secure asset.
15182: *
15183: * @param string $path
15184: * @return string
15185: * @static
15186: */
15187: public static function secureAsset($path)
15188: {
15189: /** @var \Illuminate\Routing\UrlGenerator $instance */
15190: return $instance->secureAsset($path);
15191: }
15192: /**
15193: * Generate the URL to an asset from a custom root domain such as CDN, etc.
15194: *
15195: * @param string $root
15196: * @param string $path
15197: * @param bool|null $secure
15198: * @return string
15199: * @static
15200: */
15201: public static function assetFrom($root, $path, $secure = null)
15202: {
15203: /** @var \Illuminate\Routing\UrlGenerator $instance */
15204: return $instance->assetFrom($root, $path, $secure);
15205: }
15206: /**
15207: * Get the default scheme for a raw URL.
15208: *
15209: * @param bool|null $secure
15210: * @return string
15211: * @static
15212: */
15213: public static function formatScheme($secure = null)
15214: {
15215: /** @var \Illuminate\Routing\UrlGenerator $instance */
15216: return $instance->formatScheme($secure);
15217: }
15218: /**
15219: * Create a signed route URL for a named route.
15220: *
15221: * @param string $name
15222: * @param mixed $parameters
15223: * @param \DateTimeInterface|\DateInterval|int|null $expiration
15224: * @param bool $absolute
15225: * @return string
15226: * @throws \InvalidArgumentException
15227: * @static
15228: */
15229: public static function signedRoute($name, $parameters = [], $expiration = null, $absolute = true)
15230: {
15231: /** @var \Illuminate\Routing\UrlGenerator $instance */
15232: return $instance->signedRoute($name, $parameters, $expiration, $absolute);
15233: }
15234: /**
15235: * Create a temporary signed route URL for a named route.
15236: *
15237: * @param string $name
15238: * @param \DateTimeInterface|\DateInterval|int $expiration
15239: * @param array $parameters
15240: * @param bool $absolute
15241: * @return string
15242: * @static
15243: */
15244: public static function temporarySignedRoute($name, $expiration, $parameters = [], $absolute = true)
15245: {
15246: /** @var \Illuminate\Routing\UrlGenerator $instance */
15247: return $instance->temporarySignedRoute($name, $expiration, $parameters, $absolute);
15248: }
15249: /**
15250: * Determine if the given request has a valid signature.
15251: *
15252: * @param \Illuminate\Http\Request $request
15253: * @param bool $absolute
15254: * @param array $ignoreQuery
15255: * @return bool
15256: * @static
15257: */
15258: public static function hasValidSignature($request, $absolute = true, $ignoreQuery = [])
15259: {
15260: /** @var \Illuminate\Routing\UrlGenerator $instance */
15261: return $instance->hasValidSignature($request, $absolute, $ignoreQuery);
15262: }
15263: /**
15264: * Determine if the given request has a valid signature for a relative URL.
15265: *
15266: * @param \Illuminate\Http\Request $request
15267: * @param array $ignoreQuery
15268: * @return bool
15269: * @static
15270: */
15271: public static function hasValidRelativeSignature($request, $ignoreQuery = [])
15272: {
15273: /** @var \Illuminate\Routing\UrlGenerator $instance */
15274: return $instance->hasValidRelativeSignature($request, $ignoreQuery);
15275: }
15276: /**
15277: * Determine if the signature from the given request matches the URL.
15278: *
15279: * @param \Illuminate\Http\Request $request
15280: * @param bool $absolute
15281: * @param array $ignoreQuery
15282: * @return bool
15283: * @static
15284: */
15285: public static function hasCorrectSignature($request, $absolute = true, $ignoreQuery = [])
15286: {
15287: /** @var \Illuminate\Routing\UrlGenerator $instance */
15288: return $instance->hasCorrectSignature($request, $absolute, $ignoreQuery);
15289: }
15290: /**
15291: * Determine if the expires timestamp from the given request is not from the past.
15292: *
15293: * @param \Illuminate\Http\Request $request
15294: * @return bool
15295: * @static
15296: */
15297: public static function signatureHasNotExpired($request)
15298: {
15299: /** @var \Illuminate\Routing\UrlGenerator $instance */
15300: return $instance->signatureHasNotExpired($request);
15301: }
15302: /**
15303: * Get the URL to a named route.
15304: *
15305: * @param string $name
15306: * @param mixed $parameters
15307: * @param bool $absolute
15308: * @return string
15309: * @throws \Symfony\Component\Routing\Exception\RouteNotFoundException
15310: * @static
15311: */
15312: public static function route($name, $parameters = [], $absolute = true)
15313: {
15314: /** @var \Illuminate\Routing\UrlGenerator $instance */
15315: return $instance->route($name, $parameters, $absolute);
15316: }
15317: /**
15318: * Get the URL for a given route instance.
15319: *
15320: * @param \Illuminate\Routing\Route $route
15321: * @param mixed $parameters
15322: * @param bool $absolute
15323: * @return string
15324: * @throws \Illuminate\Routing\Exceptions\UrlGenerationException
15325: * @static
15326: */
15327: public static function toRoute($route, $parameters, $absolute)
15328: {
15329: /** @var \Illuminate\Routing\UrlGenerator $instance */
15330: return $instance->toRoute($route, $parameters, $absolute);
15331: }
15332: /**
15333: * Get the URL to a controller action.
15334: *
15335: * @param string|array $action
15336: * @param mixed $parameters
15337: * @param bool $absolute
15338: * @return string
15339: * @throws \InvalidArgumentException
15340: * @static
15341: */
15342: public static function action($action, $parameters = [], $absolute = true)
15343: {
15344: /** @var \Illuminate\Routing\UrlGenerator $instance */
15345: return $instance->action($action, $parameters, $absolute);
15346: }
15347: /**
15348: * Format the array of URL parameters.
15349: *
15350: * @param mixed|array $parameters
15351: * @return array
15352: * @static
15353: */
15354: public static function formatParameters($parameters)
15355: {
15356: /** @var \Illuminate\Routing\UrlGenerator $instance */
15357: return $instance->formatParameters($parameters);
15358: }
15359: /**
15360: * Get the base URL for the request.
15361: *
15362: * @param string $scheme
15363: * @param string|null $root
15364: * @return string
15365: * @static
15366: */
15367: public static function formatRoot($scheme, $root = null)
15368: {
15369: /** @var \Illuminate\Routing\UrlGenerator $instance */
15370: return $instance->formatRoot($scheme, $root);
15371: }
15372: /**
15373: * Format the given URL segments into a single URL.
15374: *
15375: * @param string $root
15376: * @param string $path
15377: * @param \Illuminate\Routing\Route|null $route
15378: * @return string
15379: * @static
15380: */
15381: public static function format($root, $path, $route = null)
15382: {
15383: /** @var \Illuminate\Routing\UrlGenerator $instance */
15384: return $instance->format($root, $path, $route);
15385: }
15386: /**
15387: * Determine if the given path is a valid URL.
15388: *
15389: * @param string $path
15390: * @return bool
15391: * @static
15392: */
15393: public static function isValidUrl($path)
15394: {
15395: /** @var \Illuminate\Routing\UrlGenerator $instance */
15396: return $instance->isValidUrl($path);
15397: }
15398: /**
15399: * Set the default named parameters used by the URL generator.
15400: *
15401: * @param array $defaults
15402: * @return void
15403: * @static
15404: */
15405: public static function defaults($defaults)
15406: {
15407: /** @var \Illuminate\Routing\UrlGenerator $instance */
15408: $instance->defaults($defaults);
15409: }
15410: /**
15411: * Get the default named parameters used by the URL generator.
15412: *
15413: * @return array
15414: * @static
15415: */
15416: public static function getDefaultParameters()
15417: {
15418: /** @var \Illuminate\Routing\UrlGenerator $instance */
15419: return $instance->getDefaultParameters();
15420: }
15421: /**
15422: * Force the scheme for URLs.
15423: *
15424: * @param string|null $scheme
15425: * @return void
15426: * @static
15427: */
15428: public static function forceScheme($scheme)
15429: {
15430: /** @var \Illuminate\Routing\UrlGenerator $instance */
15431: $instance->forceScheme($scheme);
15432: }
15433: /**
15434: * Set the forced root URL.
15435: *
15436: * @param string|null $root
15437: * @return void
15438: * @static
15439: */
15440: public static function forceRootUrl($root)
15441: {
15442: /** @var \Illuminate\Routing\UrlGenerator $instance */
15443: $instance->forceRootUrl($root);
15444: }
15445: /**
15446: * Set a callback to be used to format the host of generated URLs.
15447: *
15448: * @param \Closure $callback
15449: * @return \Illuminate\Routing\UrlGenerator
15450: * @static
15451: */
15452: public static function formatHostUsing($callback)
15453: {
15454: /** @var \Illuminate\Routing\UrlGenerator $instance */
15455: return $instance->formatHostUsing($callback);
15456: }
15457: /**
15458: * Set a callback to be used to format the path of generated URLs.
15459: *
15460: * @param \Closure $callback
15461: * @return \Illuminate\Routing\UrlGenerator
15462: * @static
15463: */
15464: public static function formatPathUsing($callback)
15465: {
15466: /** @var \Illuminate\Routing\UrlGenerator $instance */
15467: return $instance->formatPathUsing($callback);
15468: }
15469: /**
15470: * Get the path formatter being used by the URL generator.
15471: *
15472: * @return \Closure
15473: * @static
15474: */
15475: public static function pathFormatter()
15476: {
15477: /** @var \Illuminate\Routing\UrlGenerator $instance */
15478: return $instance->pathFormatter();
15479: }
15480: /**
15481: * Get the request instance.
15482: *
15483: * @return \Illuminate\Http\Request
15484: * @static
15485: */
15486: public static function getRequest()
15487: {
15488: /** @var \Illuminate\Routing\UrlGenerator $instance */
15489: return $instance->getRequest();
15490: }
15491: /**
15492: * Set the current request instance.
15493: *
15494: * @param \Illuminate\Http\Request $request
15495: * @return void
15496: * @static
15497: */
15498: public static function setRequest($request)
15499: {
15500: /** @var \Illuminate\Routing\UrlGenerator $instance */
15501: $instance->setRequest($request);
15502: }
15503: /**
15504: * Set the route collection.
15505: *
15506: * @param \Illuminate\Routing\RouteCollectionInterface $routes
15507: * @return \Illuminate\Routing\UrlGenerator
15508: * @static
15509: */
15510: public static function setRoutes($routes)
15511: {
15512: /** @var \Illuminate\Routing\UrlGenerator $instance */
15513: return $instance->setRoutes($routes);
15514: }
15515: /**
15516: * Set the session resolver for the generator.
15517: *
15518: * @param callable $sessionResolver
15519: * @return \Illuminate\Routing\UrlGenerator
15520: * @static
15521: */
15522: public static function setSessionResolver($sessionResolver)
15523: {
15524: /** @var \Illuminate\Routing\UrlGenerator $instance */
15525: return $instance->setSessionResolver($sessionResolver);
15526: }
15527: /**
15528: * Set the encryption key resolver.
15529: *
15530: * @param callable $keyResolver
15531: * @return \Illuminate\Routing\UrlGenerator
15532: * @static
15533: */
15534: public static function setKeyResolver($keyResolver)
15535: {
15536: /** @var \Illuminate\Routing\UrlGenerator $instance */
15537: return $instance->setKeyResolver($keyResolver);
15538: }
15539: /**
15540: * Get the root controller namespace.
15541: *
15542: * @return string
15543: * @static
15544: */
15545: public static function getRootControllerNamespace()
15546: {
15547: /** @var \Illuminate\Routing\UrlGenerator $instance */
15548: return $instance->getRootControllerNamespace();
15549: }
15550: /**
15551: * Set the root controller namespace.
15552: *
15553: * @param string $rootNamespace
15554: * @return \Illuminate\Routing\UrlGenerator
15555: * @static
15556: */
15557: public static function setRootControllerNamespace($rootNamespace)
15558: {
15559: /** @var \Illuminate\Routing\UrlGenerator $instance */
15560: return $instance->setRootControllerNamespace($rootNamespace);
15561: }
15562: /**
15563: * Register a custom macro.
15564: *
15565: * @param string $name
15566: * @param object|callable $macro
15567: * @return void
15568: * @static
15569: */
15570: public static function macro($name, $macro)
15571: {
15572: \Illuminate\Routing\UrlGenerator::macro($name, $macro);
15573: }
15574: /**
15575: * Mix another object into the class.
15576: *
15577: * @param object $mixin
15578: * @param bool $replace
15579: * @return void
15580: * @throws \ReflectionException
15581: * @static
15582: */
15583: public static function mixin($mixin, $replace = true)
15584: {
15585: \Illuminate\Routing\UrlGenerator::mixin($mixin, $replace);
15586: }
15587: /**
15588: * Checks if macro is registered.
15589: *
15590: * @param string $name
15591: * @return bool
15592: * @static
15593: */
15594: public static function hasMacro($name)
15595: {
15596: return \Illuminate\Routing\UrlGenerator::hasMacro($name);
15597: }
15598: /**
15599: * Flush the existing macros.
15600: *
15601: * @return void
15602: * @static
15603: */
15604: public static function flushMacros()
15605: {
15606: \Illuminate\Routing\UrlGenerator::flushMacros();
15607: }
15608:
15609: }
15610: /**
15611: *
15612: *
15613: * @see \Illuminate\Validation\Factory
15614: */
15615: class Validator {
15616: /**
15617: * Create a new Validator instance.
15618: *
15619: * @param array $data
15620: * @param array $rules
15621: * @param array $messages
15622: * @param array $customAttributes
15623: * @return \Illuminate\Validation\Validator
15624: * @static
15625: */
15626: public static function make($data, $rules, $messages = [], $customAttributes = [])
15627: {
15628: /** @var \Illuminate\Validation\Factory $instance */
15629: return $instance->make($data, $rules, $messages, $customAttributes);
15630: }
15631: /**
15632: * Validate the given data against the provided rules.
15633: *
15634: * @param array $data
15635: * @param array $rules
15636: * @param array $messages
15637: * @param array $customAttributes
15638: * @return array
15639: * @throws \Illuminate\Validation\ValidationException
15640: * @static
15641: */
15642: public static function validate($data, $rules, $messages = [], $customAttributes = [])
15643: {
15644: /** @var \Illuminate\Validation\Factory $instance */
15645: return $instance->validate($data, $rules, $messages, $customAttributes);
15646: }
15647: /**
15648: * Register a custom validator extension.
15649: *
15650: * @param string $rule
15651: * @param \Closure|string $extension
15652: * @param string|null $message
15653: * @return void
15654: * @static
15655: */
15656: public static function extend($rule, $extension, $message = null)
15657: {
15658: /** @var \Illuminate\Validation\Factory $instance */
15659: $instance->extend($rule, $extension, $message);
15660: }
15661: /**
15662: * Register a custom implicit validator extension.
15663: *
15664: * @param string $rule
15665: * @param \Closure|string $extension
15666: * @param string|null $message
15667: * @return void
15668: * @static
15669: */
15670: public static function extendImplicit($rule, $extension, $message = null)
15671: {
15672: /** @var \Illuminate\Validation\Factory $instance */
15673: $instance->extendImplicit($rule, $extension, $message);
15674: }
15675: /**
15676: * Register a custom dependent validator extension.
15677: *
15678: * @param string $rule
15679: * @param \Closure|string $extension
15680: * @param string|null $message
15681: * @return void
15682: * @static
15683: */
15684: public static function extendDependent($rule, $extension, $message = null)
15685: {
15686: /** @var \Illuminate\Validation\Factory $instance */
15687: $instance->extendDependent($rule, $extension, $message);
15688: }
15689: /**
15690: * Register a custom validator message replacer.
15691: *
15692: * @param string $rule
15693: * @param \Closure|string $replacer
15694: * @return void
15695: * @static
15696: */
15697: public static function replacer($rule, $replacer)
15698: {
15699: /** @var \Illuminate\Validation\Factory $instance */
15700: $instance->replacer($rule, $replacer);
15701: }
15702: /**
15703: * Indicate that unvalidated array keys should be included in validated data when the parent array is validated.
15704: *
15705: * @return void
15706: * @static
15707: */
15708: public static function includeUnvalidatedArrayKeys()
15709: {
15710: /** @var \Illuminate\Validation\Factory $instance */
15711: $instance->includeUnvalidatedArrayKeys();
15712: }
15713: /**
15714: * Indicate that unvalidated array keys should be excluded from the validated data, even if the parent array was validated.
15715: *
15716: * @return void
15717: * @static
15718: */
15719: public static function excludeUnvalidatedArrayKeys()
15720: {
15721: /** @var \Illuminate\Validation\Factory $instance */
15722: $instance->excludeUnvalidatedArrayKeys();
15723: }
15724: /**
15725: * Set the Validator instance resolver.
15726: *
15727: * @param \Closure $resolver
15728: * @return void
15729: * @static
15730: */
15731: public static function resolver($resolver)
15732: {
15733: /** @var \Illuminate\Validation\Factory $instance */
15734: $instance->resolver($resolver);
15735: }
15736: /**
15737: * Get the Translator implementation.
15738: *
15739: * @return \Illuminate\Contracts\Translation\Translator
15740: * @static
15741: */
15742: public static function getTranslator()
15743: {
15744: /** @var \Illuminate\Validation\Factory $instance */
15745: return $instance->getTranslator();
15746: }
15747: /**
15748: * Get the Presence Verifier implementation.
15749: *
15750: * @return \Illuminate\Validation\PresenceVerifierInterface
15751: * @static
15752: */
15753: public static function getPresenceVerifier()
15754: {
15755: /** @var \Illuminate\Validation\Factory $instance */
15756: return $instance->getPresenceVerifier();
15757: }
15758: /**
15759: * Set the Presence Verifier implementation.
15760: *
15761: * @param \Illuminate\Validation\PresenceVerifierInterface $presenceVerifier
15762: * @return void
15763: * @static
15764: */
15765: public static function setPresenceVerifier($presenceVerifier)
15766: {
15767: /** @var \Illuminate\Validation\Factory $instance */
15768: $instance->setPresenceVerifier($presenceVerifier);
15769: }
15770: /**
15771: * Get the container instance used by the validation factory.
15772: *
15773: * @return \Illuminate\Contracts\Container\Container|null
15774: * @static
15775: */
15776: public static function getContainer()
15777: {
15778: /** @var \Illuminate\Validation\Factory $instance */
15779: return $instance->getContainer();
15780: }
15781: /**
15782: * Set the container instance used by the validation factory.
15783: *
15784: * @param \Illuminate\Contracts\Container\Container $container
15785: * @return \Illuminate\Validation\Factory
15786: * @static
15787: */
15788: public static function setContainer($container)
15789: {
15790: /** @var \Illuminate\Validation\Factory $instance */
15791: return $instance->setContainer($container);
15792: }
15793:
15794: }
15795: /**
15796: *
15797: *
15798: * @see \Illuminate\View\Factory
15799: */
15800: class View {
15801: /**
15802: * Get the evaluated view contents for the given view.
15803: *
15804: * @param string $path
15805: * @param \Illuminate\Contracts\Support\Arrayable|array $data
15806: * @param array $mergeData
15807: * @return \Illuminate\Contracts\View\View
15808: * @static
15809: */
15810: public static function file($path, $data = [], $mergeData = [])
15811: {
15812: /** @var \Illuminate\View\Factory $instance */
15813: return $instance->file($path, $data, $mergeData);
15814: }
15815: /**
15816: * Get the evaluated view contents for the given view.
15817: *
15818: * @param string $view
15819: * @param \Illuminate\Contracts\Support\Arrayable|array $data
15820: * @param array $mergeData
15821: * @return \Illuminate\Contracts\View\View
15822: * @static
15823: */
15824: public static function make($view, $data = [], $mergeData = [])
15825: {
15826: /** @var \Illuminate\View\Factory $instance */
15827: return $instance->make($view, $data, $mergeData);
15828: }
15829: /**
15830: * Get the first view that actually exists from the given list.
15831: *
15832: * @param array $views
15833: * @param \Illuminate\Contracts\Support\Arrayable|array $data
15834: * @param array $mergeData
15835: * @return \Illuminate\Contracts\View\View
15836: * @throws \InvalidArgumentException
15837: * @static
15838: */
15839: public static function first($views, $data = [], $mergeData = [])
15840: {
15841: /** @var \Illuminate\View\Factory $instance */
15842: return $instance->first($views, $data, $mergeData);
15843: }
15844: /**
15845: * Get the rendered content of the view based on a given condition.
15846: *
15847: * @param bool $condition
15848: * @param string $view
15849: * @param \Illuminate\Contracts\Support\Arrayable|array $data
15850: * @param array $mergeData
15851: * @return string
15852: * @static
15853: */
15854: public static function renderWhen($condition, $view, $data = [], $mergeData = [])
15855: {
15856: /** @var \Illuminate\View\Factory $instance */
15857: return $instance->renderWhen($condition, $view, $data, $mergeData);
15858: }
15859: /**
15860: * Get the rendered content of the view based on the negation of a given condition.
15861: *
15862: * @param bool $condition
15863: * @param string $view
15864: * @param \Illuminate\Contracts\Support\Arrayable|array $data
15865: * @param array $mergeData
15866: * @return string
15867: * @static
15868: */
15869: public static function renderUnless($condition, $view, $data = [], $mergeData = [])
15870: {
15871: /** @var \Illuminate\View\Factory $instance */
15872: return $instance->renderUnless($condition, $view, $data, $mergeData);
15873: }
15874: /**
15875: * Get the rendered contents of a partial from a loop.
15876: *
15877: * @param string $view
15878: * @param array $data
15879: * @param string $iterator
15880: * @param string $empty
15881: * @return string
15882: * @static
15883: */
15884: public static function renderEach($view, $data, $iterator, $empty = 'raw|')
15885: {
15886: /** @var \Illuminate\View\Factory $instance */
15887: return $instance->renderEach($view, $data, $iterator, $empty);
15888: }
15889: /**
15890: * Determine if a given view exists.
15891: *
15892: * @param string $view
15893: * @return bool
15894: * @static
15895: */
15896: public static function exists($view)
15897: {
15898: /** @var \Illuminate\View\Factory $instance */
15899: return $instance->exists($view);
15900: }
15901: /**
15902: * Get the appropriate view engine for the given path.
15903: *
15904: * @param string $path
15905: * @return \Illuminate\Contracts\View\Engine
15906: * @throws \InvalidArgumentException
15907: * @static
15908: */
15909: public static function getEngineFromPath($path)
15910: {
15911: /** @var \Illuminate\View\Factory $instance */
15912: return $instance->getEngineFromPath($path);
15913: }
15914: /**
15915: * Add a piece of shared data to the environment.
15916: *
15917: * @param array|string $key
15918: * @param mixed|null $value
15919: * @return mixed
15920: * @static
15921: */
15922: public static function share($key, $value = null)
15923: {
15924: /** @var \Illuminate\View\Factory $instance */
15925: return $instance->share($key, $value);
15926: }
15927: /**
15928: * Increment the rendering counter.
15929: *
15930: * @return void
15931: * @static
15932: */
15933: public static function incrementRender()
15934: {
15935: /** @var \Illuminate\View\Factory $instance */
15936: $instance->incrementRender();
15937: }
15938: /**
15939: * Decrement the rendering counter.
15940: *
15941: * @return void
15942: * @static
15943: */
15944: public static function decrementRender()
15945: {
15946: /** @var \Illuminate\View\Factory $instance */
15947: $instance->decrementRender();
15948: }
15949: /**
15950: * Check if there are no active render operations.
15951: *
15952: * @return bool
15953: * @static
15954: */
15955: public static function doneRendering()
15956: {
15957: /** @var \Illuminate\View\Factory $instance */
15958: return $instance->doneRendering();
15959: }
15960: /**
15961: * Determine if the given once token has been rendered.
15962: *
15963: * @param string $id
15964: * @return bool
15965: * @static
15966: */
15967: public static function hasRenderedOnce($id)
15968: {
15969: /** @var \Illuminate\View\Factory $instance */
15970: return $instance->hasRenderedOnce($id);
15971: }
15972: /**
15973: * Mark the given once token as having been rendered.
15974: *
15975: * @param string $id
15976: * @return void
15977: * @static
15978: */
15979: public static function markAsRenderedOnce($id)
15980: {
15981: /** @var \Illuminate\View\Factory $instance */
15982: $instance->markAsRenderedOnce($id);
15983: }
15984: /**
15985: * Add a location to the array of view locations.
15986: *
15987: * @param string $location
15988: * @return void
15989: * @static
15990: */
15991: public static function addLocation($location)
15992: {
15993: /** @var \Illuminate\View\Factory $instance */
15994: $instance->addLocation($location);
15995: }
15996: /**
15997: * Add a new namespace to the loader.
15998: *
15999: * @param string $namespace
16000: * @param string|array $hints
16001: * @return \Illuminate\View\Factory
16002: * @static
16003: */
16004: public static function addNamespace($namespace, $hints)
16005: {
16006: /** @var \Illuminate\View\Factory $instance */
16007: return $instance->addNamespace($namespace, $hints);
16008: }
16009: /**
16010: * Prepend a new namespace to the loader.
16011: *
16012: * @param string $namespace
16013: * @param string|array $hints
16014: * @return \Illuminate\View\Factory
16015: * @static
16016: */
16017: public static function prependNamespace($namespace, $hints)
16018: {
16019: /** @var \Illuminate\View\Factory $instance */
16020: return $instance->prependNamespace($namespace, $hints);
16021: }
16022: /**
16023: * Replace the namespace hints for the given namespace.
16024: *
16025: * @param string $namespace
16026: * @param string|array $hints
16027: * @return \Illuminate\View\Factory
16028: * @static
16029: */
16030: public static function replaceNamespace($namespace, $hints)
16031: {
16032: /** @var \Illuminate\View\Factory $instance */
16033: return $instance->replaceNamespace($namespace, $hints);
16034: }
16035: /**
16036: * Register a valid view extension and its engine.
16037: *
16038: * @param string $extension
16039: * @param string $engine
16040: * @param \Closure|null $resolver
16041: * @return void
16042: * @static
16043: */
16044: public static function addExtension($extension, $engine, $resolver = null)
16045: {
16046: /** @var \Illuminate\View\Factory $instance */
16047: $instance->addExtension($extension, $engine, $resolver);
16048: }
16049: /**
16050: * Flush all of the factory state like sections and stacks.
16051: *
16052: * @return void
16053: * @static
16054: */
16055: public static function flushState()
16056: {
16057: /** @var \Illuminate\View\Factory $instance */
16058: $instance->flushState();
16059: }
16060: /**
16061: * Flush all of the section contents if done rendering.
16062: *
16063: * @return void
16064: * @static
16065: */
16066: public static function flushStateIfDoneRendering()
16067: {
16068: /** @var \Illuminate\View\Factory $instance */
16069: $instance->flushStateIfDoneRendering();
16070: }
16071: /**
16072: * Get the extension to engine bindings.
16073: *
16074: * @return array
16075: * @static
16076: */
16077: public static function getExtensions()
16078: {
16079: /** @var \Illuminate\View\Factory $instance */
16080: return $instance->getExtensions();
16081: }
16082: /**
16083: * Get the engine resolver instance.
16084: *
16085: * @return \Illuminate\View\Engines\EngineResolver
16086: * @static
16087: */
16088: public static function getEngineResolver()
16089: {
16090: /** @var \Illuminate\View\Factory $instance */
16091: return $instance->getEngineResolver();
16092: }
16093: /**
16094: * Get the view finder instance.
16095: *
16096: * @return \Illuminate\View\ViewFinderInterface
16097: * @static
16098: */
16099: public static function getFinder()
16100: {
16101: /** @var \Illuminate\View\Factory $instance */
16102: return $instance->getFinder();
16103: }
16104: /**
16105: * Set the view finder instance.
16106: *
16107: * @param \Illuminate\View\ViewFinderInterface $finder
16108: * @return void
16109: * @static
16110: */
16111: public static function setFinder($finder)
16112: {
16113: /** @var \Illuminate\View\Factory $instance */
16114: $instance->setFinder($finder);
16115: }
16116: /**
16117: * Flush the cache of views located by the finder.
16118: *
16119: * @return void
16120: * @static
16121: */
16122: public static function flushFinderCache()
16123: {
16124: /** @var \Illuminate\View\Factory $instance */
16125: $instance->flushFinderCache();
16126: }
16127: /**
16128: * Get the event dispatcher instance.
16129: *
16130: * @return \Illuminate\Contracts\Events\Dispatcher
16131: * @static
16132: */
16133: public static function getDispatcher()
16134: {
16135: /** @var \Illuminate\View\Factory $instance */
16136: return $instance->getDispatcher();
16137: }
16138: /**
16139: * Set the event dispatcher instance.
16140: *
16141: * @param \Illuminate\Contracts\Events\Dispatcher $events
16142: * @return void
16143: * @static
16144: */
16145: public static function setDispatcher($events)
16146: {
16147: /** @var \Illuminate\View\Factory $instance */
16148: $instance->setDispatcher($events);
16149: }
16150: /**
16151: * Get the IoC container instance.
16152: *
16153: * @return \Illuminate\Contracts\Container\Container
16154: * @static
16155: */
16156: public static function getContainer()
16157: {
16158: /** @var \Illuminate\View\Factory $instance */
16159: return $instance->getContainer();
16160: }
16161: /**
16162: * Set the IoC container instance.
16163: *
16164: * @param \Illuminate\Contracts\Container\Container $container
16165: * @return void
16166: * @static
16167: */
16168: public static function setContainer($container)
16169: {
16170: /** @var \Illuminate\View\Factory $instance */
16171: $instance->setContainer($container);
16172: }
16173: /**
16174: * Get an item from the shared data.
16175: *
16176: * @param string $key
16177: * @param mixed $default
16178: * @return mixed
16179: * @static
16180: */
16181: public static function shared($key, $default = null)
16182: {
16183: /** @var \Illuminate\View\Factory $instance */
16184: return $instance->shared($key, $default);
16185: }
16186: /**
16187: * Get all of the shared data for the environment.
16188: *
16189: * @return array
16190: * @static
16191: */
16192: public static function getShared()
16193: {
16194: /** @var \Illuminate\View\Factory $instance */
16195: return $instance->getShared();
16196: }
16197: /**
16198: * Register a custom macro.
16199: *
16200: * @param string $name
16201: * @param object|callable $macro
16202: * @return void
16203: * @static
16204: */
16205: public static function macro($name, $macro)
16206: {
16207: \Illuminate\View\Factory::macro($name, $macro);
16208: }
16209: /**
16210: * Mix another object into the class.
16211: *
16212: * @param object $mixin
16213: * @param bool $replace
16214: * @return void
16215: * @throws \ReflectionException
16216: * @static
16217: */
16218: public static function mixin($mixin, $replace = true)
16219: {
16220: \Illuminate\View\Factory::mixin($mixin, $replace);
16221: }
16222: /**
16223: * Checks if macro is registered.
16224: *
16225: * @param string $name
16226: * @return bool
16227: * @static
16228: */
16229: public static function hasMacro($name)
16230: {
16231: return \Illuminate\View\Factory::hasMacro($name);
16232: }
16233: /**
16234: * Flush the existing macros.
16235: *
16236: * @return void
16237: * @static
16238: */
16239: public static function flushMacros()
16240: {
16241: \Illuminate\View\Factory::flushMacros();
16242: }
16243: /**
16244: * Start a component rendering process.
16245: *
16246: * @param \Illuminate\Contracts\View\View|\Illuminate\Contracts\Support\Htmlable|\Closure|string $view
16247: * @param array $data
16248: * @return void
16249: * @static
16250: */
16251: public static function startComponent($view, $data = [])
16252: {
16253: /** @var \Illuminate\View\Factory $instance */
16254: $instance->startComponent($view, $data);
16255: }
16256: /**
16257: * Get the first view that actually exists from the given list, and start a component.
16258: *
16259: * @param array $names
16260: * @param array $data
16261: * @return void
16262: * @static
16263: */
16264: public static function startComponentFirst($names, $data = [])
16265: {
16266: /** @var \Illuminate\View\Factory $instance */
16267: $instance->startComponentFirst($names, $data);
16268: }
16269: /**
16270: * Render the current component.
16271: *
16272: * @return string
16273: * @static
16274: */
16275: public static function renderComponent()
16276: {
16277: /** @var \Illuminate\View\Factory $instance */
16278: return $instance->renderComponent();
16279: }
16280: /**
16281: * Get an item from the component data that exists above the current component.
16282: *
16283: * @param string $key
16284: * @param mixed $default
16285: * @return mixed|null
16286: * @static
16287: */
16288: public static function getConsumableComponentData($key, $default = null)
16289: {
16290: /** @var \Illuminate\View\Factory $instance */
16291: return $instance->getConsumableComponentData($key, $default);
16292: }
16293: /**
16294: * Start the slot rendering process.
16295: *
16296: * @param string $name
16297: * @param string|null $content
16298: * @param array $attributes
16299: * @return void
16300: * @static
16301: */
16302: public static function slot($name, $content = null, $attributes = [])
16303: {
16304: /** @var \Illuminate\View\Factory $instance */
16305: $instance->slot($name, $content, $attributes);
16306: }
16307: /**
16308: * Save the slot content for rendering.
16309: *
16310: * @return void
16311: * @static
16312: */
16313: public static function endSlot()
16314: {
16315: /** @var \Illuminate\View\Factory $instance */
16316: $instance->endSlot();
16317: }
16318: /**
16319: * Register a view creator event.
16320: *
16321: * @param array|string $views
16322: * @param \Closure|string $callback
16323: * @return array
16324: * @static
16325: */
16326: public static function creator($views, $callback)
16327: {
16328: /** @var \Illuminate\View\Factory $instance */
16329: return $instance->creator($views, $callback);
16330: }
16331: /**
16332: * Register multiple view composers via an array.
16333: *
16334: * @param array $composers
16335: * @return array
16336: * @static
16337: */
16338: public static function composers($composers)
16339: {
16340: /** @var \Illuminate\View\Factory $instance */
16341: return $instance->composers($composers);
16342: }
16343: /**
16344: * Register a view composer event.
16345: *
16346: * @param array|string $views
16347: * @param \Closure|string $callback
16348: * @return array
16349: * @static
16350: */
16351: public static function composer($views, $callback)
16352: {
16353: /** @var \Illuminate\View\Factory $instance */
16354: return $instance->composer($views, $callback);
16355: }
16356: /**
16357: * Call the composer for a given view.
16358: *
16359: * @param \Illuminate\Contracts\View\View $view
16360: * @return void
16361: * @static
16362: */
16363: public static function callComposer($view)
16364: {
16365: /** @var \Illuminate\View\Factory $instance */
16366: $instance->callComposer($view);
16367: }
16368: /**
16369: * Call the creator for a given view.
16370: *
16371: * @param \Illuminate\Contracts\View\View $view
16372: * @return void
16373: * @static
16374: */
16375: public static function callCreator($view)
16376: {
16377: /** @var \Illuminate\View\Factory $instance */
16378: $instance->callCreator($view);
16379: }
16380: /**
16381: * Start injecting content into a section.
16382: *
16383: * @param string $section
16384: * @param string|null $content
16385: * @return void
16386: * @static
16387: */
16388: public static function startSection($section, $content = null)
16389: {
16390: /** @var \Illuminate\View\Factory $instance */
16391: $instance->startSection($section, $content);
16392: }
16393: /**
16394: * Inject inline content into a section.
16395: *
16396: * @param string $section
16397: * @param string $content
16398: * @return void
16399: * @static
16400: */
16401: public static function inject($section, $content)
16402: {
16403: /** @var \Illuminate\View\Factory $instance */
16404: $instance->inject($section, $content);
16405: }
16406: /**
16407: * Stop injecting content into a section and return its contents.
16408: *
16409: * @return string
16410: * @static
16411: */
16412: public static function yieldSection()
16413: {
16414: /** @var \Illuminate\View\Factory $instance */
16415: return $instance->yieldSection();
16416: }
16417: /**
16418: * Stop injecting content into a section.
16419: *
16420: * @param bool $overwrite
16421: * @return string
16422: * @throws \InvalidArgumentException
16423: * @static
16424: */
16425: public static function stopSection($overwrite = false)
16426: {
16427: /** @var \Illuminate\View\Factory $instance */
16428: return $instance->stopSection($overwrite);
16429: }
16430: /**
16431: * Stop injecting content into a section and append it.
16432: *
16433: * @return string
16434: * @throws \InvalidArgumentException
16435: * @static
16436: */
16437: public static function appendSection()
16438: {
16439: /** @var \Illuminate\View\Factory $instance */
16440: return $instance->appendSection();
16441: }
16442: /**
16443: * Get the string contents of a section.
16444: *
16445: * @param string $section
16446: * @param string $default
16447: * @return string
16448: * @static
16449: */
16450: public static function yieldContent($section, $default = '')
16451: {
16452: /** @var \Illuminate\View\Factory $instance */
16453: return $instance->yieldContent($section, $default);
16454: }
16455: /**
16456: * Get the parent placeholder for the current request.
16457: *
16458: * @param string $section
16459: * @return string
16460: * @static
16461: */
16462: public static function parentPlaceholder($section = '')
16463: {
16464: return \Illuminate\View\Factory::parentPlaceholder($section);
16465: }
16466: /**
16467: * Check if section exists.
16468: *
16469: * @param string $name
16470: * @return bool
16471: * @static
16472: */
16473: public static function hasSection($name)
16474: {
16475: /** @var \Illuminate\View\Factory $instance */
16476: return $instance->hasSection($name);
16477: }
16478: /**
16479: * Check if section does not exist.
16480: *
16481: * @param string $name
16482: * @return bool
16483: * @static
16484: */
16485: public static function sectionMissing($name)
16486: {
16487: /** @var \Illuminate\View\Factory $instance */
16488: return $instance->sectionMissing($name);
16489: }
16490: /**
16491: * Get the contents of a section.
16492: *
16493: * @param string $name
16494: * @param string|null $default
16495: * @return mixed
16496: * @static
16497: */
16498: public static function getSection($name, $default = null)
16499: {
16500: /** @var \Illuminate\View\Factory $instance */
16501: return $instance->getSection($name, $default);
16502: }
16503: /**
16504: * Get the entire array of sections.
16505: *
16506: * @return array
16507: * @static
16508: */
16509: public static function getSections()
16510: {
16511: /** @var \Illuminate\View\Factory $instance */
16512: return $instance->getSections();
16513: }
16514: /**
16515: * Flush all of the sections.
16516: *
16517: * @return void
16518: * @static
16519: */
16520: public static function flushSections()
16521: {
16522: /** @var \Illuminate\View\Factory $instance */
16523: $instance->flushSections();
16524: }
16525: /**
16526: * Add new loop to the stack.
16527: *
16528: * @param \Countable|array $data
16529: * @return void
16530: * @static
16531: */
16532: public static function addLoop($data)
16533: {
16534: /** @var \Illuminate\View\Factory $instance */
16535: $instance->addLoop($data);
16536: }
16537: /**
16538: * Increment the top loop's indices.
16539: *
16540: * @return void
16541: * @static
16542: */
16543: public static function incrementLoopIndices()
16544: {
16545: /** @var \Illuminate\View\Factory $instance */
16546: $instance->incrementLoopIndices();
16547: }
16548: /**
16549: * Pop a loop from the top of the loop stack.
16550: *
16551: * @return void
16552: * @static
16553: */
16554: public static function popLoop()
16555: {
16556: /** @var \Illuminate\View\Factory $instance */
16557: $instance->popLoop();
16558: }
16559: /**
16560: * Get an instance of the last loop in the stack.
16561: *
16562: * @return \stdClass|null
16563: * @static
16564: */
16565: public static function getLastLoop()
16566: {
16567: /** @var \Illuminate\View\Factory $instance */
16568: return $instance->getLastLoop();
16569: }
16570: /**
16571: * Get the entire loop stack.
16572: *
16573: * @return array
16574: * @static
16575: */
16576: public static function getLoopStack()
16577: {
16578: /** @var \Illuminate\View\Factory $instance */
16579: return $instance->getLoopStack();
16580: }
16581: /**
16582: * Start injecting content into a push section.
16583: *
16584: * @param string $section
16585: * @param string $content
16586: * @return void
16587: * @static
16588: */
16589: public static function startPush($section, $content = '')
16590: {
16591: /** @var \Illuminate\View\Factory $instance */
16592: $instance->startPush($section, $content);
16593: }
16594: /**
16595: * Stop injecting content into a push section.
16596: *
16597: * @return string
16598: * @throws \InvalidArgumentException
16599: * @static
16600: */
16601: public static function stopPush()
16602: {
16603: /** @var \Illuminate\View\Factory $instance */
16604: return $instance->stopPush();
16605: }
16606: /**
16607: * Start prepending content into a push section.
16608: *
16609: * @param string $section
16610: * @param string $content
16611: * @return void
16612: * @static
16613: */
16614: public static function startPrepend($section, $content = '')
16615: {
16616: /** @var \Illuminate\View\Factory $instance */
16617: $instance->startPrepend($section, $content);
16618: }
16619: /**
16620: * Stop prepending content into a push section.
16621: *
16622: * @return string
16623: * @throws \InvalidArgumentException
16624: * @static
16625: */
16626: public static function stopPrepend()
16627: {
16628: /** @var \Illuminate\View\Factory $instance */
16629: return $instance->stopPrepend();
16630: }
16631: /**
16632: * Get the string contents of a push section.
16633: *
16634: * @param string $section
16635: * @param string $default
16636: * @return string
16637: * @static
16638: */
16639: public static function yieldPushContent($section, $default = '')
16640: {
16641: /** @var \Illuminate\View\Factory $instance */
16642: return $instance->yieldPushContent($section, $default);
16643: }
16644: /**
16645: * Flush all of the stacks.
16646: *
16647: * @return void
16648: * @static
16649: */
16650: public static function flushStacks()
16651: {
16652: /** @var \Illuminate\View\Factory $instance */
16653: $instance->flushStacks();
16654: }
16655: /**
16656: * Start a translation block.
16657: *
16658: * @param array $replacements
16659: * @return void
16660: * @static
16661: */
16662: public static function startTranslation($replacements = [])
16663: {
16664: /** @var \Illuminate\View\Factory $instance */
16665: $instance->startTranslation($replacements);
16666: }
16667: /**
16668: * Render the current translation.
16669: *
16670: * @return string
16671: * @static
16672: */
16673: public static function renderTranslation()
16674: {
16675: /** @var \Illuminate\View\Factory $instance */
16676: return $instance->renderTranslation();
16677: }
16678:
16679: }
16680:
16681: }
16682:
16683: namespace Illuminate\Support {
16684: /**
16685: *
16686: *
16687: */
16688: class Arr {
16689:
16690: }
16691: /**
16692: *
16693: *
16694: */
16695: class Str {
16696: /**
16697: *
16698: *
16699: * @see \Calebporzio\AwesomeHelpers\StrMacros::extract()
16700: * @param mixed $string
16701: * @param mixed $pattern
16702: * @static
16703: */
16704: public static function extract($string, $pattern)
16705: {
16706: return \Illuminate\Support\Str::extract($string, $pattern);
16707: }
16708: /**
16709: *
16710: *
16711: * @see \Calebporzio\AwesomeHelpers\StrMacros::validate()
16712: * @param mixed $data
16713: * @param mixed $rules
16714: * @static
16715: */
16716: public static function validate($data, $rules)
16717: {
16718: return \Illuminate\Support\Str::validate($data, $rules);
16719: }
16720: /**
16721: *
16722: *
16723: * @see \Calebporzio\AwesomeHelpers\StrMacros::wrap()
16724: * @param mixed $value
16725: * @param mixed $cap
16726: * @static
16727: */
16728: public static function wrap($value, $cap)
16729: {
16730: return \Illuminate\Support\Str::wrap($value, $cap);
16731: }
16732: /**
16733: *
16734: *
16735: * @see \Filament\Support\SupportServiceProvider::packageBooted()
16736: * @param string $html
16737: * @return string
16738: * @static
16739: */
16740: public static function sanitizeHtml($html)
16741: {
16742: return \Illuminate\Support\Str::sanitizeHtml($html);
16743: }
16744:
16745: }
16746: /**
16747: *
16748: *
16749: * @template TKey of array-key
16750: * @template TValue
16751: * @implements \ArrayAccess<TKey, TValue>
16752: * @implements \Illuminate\Support\Enumerable<TKey, TValue>
16753: */
16754: class Collection {
16755: /**
16756: *
16757: *
16758: * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros()
16759: * @param string $description
16760: * @static
16761: */
16762: public static function ray($description = '')
16763: {
16764: return \Illuminate\Support\Collection::ray($description);
16765: }
16766:
16767: }
16768: /**
16769: *
16770: *
16771: */
16772: class Stringable {
16773: /**
16774: *
16775: *
16776: * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros()
16777: * @param string $description
16778: * @static
16779: */
16780: public static function ray($description = '')
16781: {
16782: return \Illuminate\Support\Stringable::ray($description);
16783: }
16784: /**
16785: *
16786: *
16787: * @see \Filament\Support\SupportServiceProvider::packageBooted()
16788: * @return \Illuminate\Support\Stringable
16789: * @static
16790: */
16791: public static function sanitizeHtml()
16792: {
16793: return \Illuminate\Support\Stringable::sanitizeHtml();
16794: }
16795:
16796: }
16797:
16798: }
16799:
16800: namespace Clockwork\Support\Laravel {
16801: /**
16802: *
16803: *
16804: */
16805: class Facade {
16806: /**
16807: *
16808: *
16809: * @static
16810: */
16811: public static function addDataSource($dataSource)
16812: {
16813: /** @var \Clockwork\Clockwork $instance */
16814: return $instance->addDataSource($dataSource);
16815: }
16816: /**
16817: *
16818: *
16819: * @static
16820: */
16821: public static function resolveRequest()
16822: {
16823: /** @var \Clockwork\Clockwork $instance */
16824: return $instance->resolveRequest();
16825: }
16826: /**
16827: *
16828: *
16829: * @static
16830: */
16831: public static function resolveAsCommand($name, $exitCode = null, $arguments = [], $options = [], $argumentsDefaults = [], $optionsDefaults = [], $output = null)
16832: {
16833: /** @var \Clockwork\Clockwork $instance */
16834: return $instance->resolveAsCommand($name, $exitCode, $arguments, $options, $argumentsDefaults, $optionsDefaults, $output);
16835: }
16836: /**
16837: *
16838: *
16839: * @static
16840: */
16841: public static function resolveAsQueueJob($name, $description = null, $status = 'processed', $payload = [], $queue = null, $connection = null, $options = [])
16842: {
16843: /** @var \Clockwork\Clockwork $instance */
16844: return $instance->resolveAsQueueJob($name, $description, $status, $payload, $queue, $connection, $options);
16845: }
16846: /**
16847: *
16848: *
16849: * @static
16850: */
16851: public static function resolveAsTest($name, $status = 'passed', $statusMessage = null, $asserts = [])
16852: {
16853: /** @var \Clockwork\Clockwork $instance */
16854: return $instance->resolveAsTest($name, $status, $statusMessage, $asserts);
16855: }
16856: /**
16857: *
16858: *
16859: * @static
16860: */
16861: public static function extendRequest($request = null)
16862: {
16863: /** @var \Clockwork\Clockwork $instance */
16864: return $instance->extendRequest($request);
16865: }
16866: /**
16867: *
16868: *
16869: * @static
16870: */
16871: public static function storeRequest()
16872: {
16873: /** @var \Clockwork\Clockwork $instance */
16874: return $instance->storeRequest();
16875: }
16876: /**
16877: *
16878: *
16879: * @static
16880: */
16881: public static function reset()
16882: {
16883: /** @var \Clockwork\Clockwork $instance */
16884: return $instance->reset();
16885: }
16886: /**
16887: *
16888: *
16889: * @static
16890: */
16891: public static function request($request = null)
16892: {
16893: /** @var \Clockwork\Clockwork $instance */
16894: return $instance->request($request);
16895: }
16896: /**
16897: *
16898: *
16899: * @static
16900: */
16901: public static function log($level = null, $message = null, $context = [])
16902: {
16903: /** @var \Clockwork\Clockwork $instance */
16904: return $instance->log($level, $message, $context);
16905: }
16906: /**
16907: *
16908: *
16909: * @static
16910: */
16911: public static function timeline()
16912: {
16913: /** @var \Clockwork\Clockwork $instance */
16914: return $instance->timeline();
16915: }
16916: /**
16917: *
16918: *
16919: * @static
16920: */
16921: public static function event($description, $data = [])
16922: {
16923: /** @var \Clockwork\Clockwork $instance */
16924: return $instance->event($description, $data);
16925: }
16926: /**
16927: *
16928: *
16929: * @static
16930: */
16931: public static function shouldCollect($shouldCollect = null)
16932: {
16933: /** @var \Clockwork\Clockwork $instance */
16934: return $instance->shouldCollect($shouldCollect);
16935: }
16936: /**
16937: *
16938: *
16939: * @static
16940: */
16941: public static function shouldRecord($shouldRecord = null)
16942: {
16943: /** @var \Clockwork\Clockwork $instance */
16944: return $instance->shouldRecord($shouldRecord);
16945: }
16946: /**
16947: *
16948: *
16949: * @static
16950: */
16951: public static function dataSources($dataSources = null)
16952: {
16953: /** @var \Clockwork\Clockwork $instance */
16954: return $instance->dataSources($dataSources);
16955: }
16956: /**
16957: *
16958: *
16959: * @static
16960: */
16961: public static function storage($storage = null)
16962: {
16963: /** @var \Clockwork\Clockwork $instance */
16964: return $instance->storage($storage);
16965: }
16966: /**
16967: *
16968: *
16969: * @static
16970: */
16971: public static function authenticator($authenticator = null)
16972: {
16973: /** @var \Clockwork\Clockwork $instance */
16974: return $instance->authenticator($authenticator);
16975: }
16976: /**
16977: *
16978: *
16979: * @static
16980: */
16981: public static function getDataSources()
16982: {
16983: /** @var \Clockwork\Clockwork $instance */
16984: return $instance->getDataSources();
16985: }
16986: /**
16987: *
16988: *
16989: * @static
16990: */
16991: public static function getRequest()
16992: {
16993: /** @var \Clockwork\Clockwork $instance */
16994: return $instance->getRequest();
16995: }
16996: /**
16997: *
16998: *
16999: * @static
17000: */
17001: public static function setRequest($request)
17002: {
17003: /** @var \Clockwork\Clockwork $instance */
17004: return $instance->setRequest($request);
17005: }
17006: /**
17007: *
17008: *
17009: * @static
17010: */
17011: public static function getStorage()
17012: {
17013: /** @var \Clockwork\Clockwork $instance */
17014: return $instance->getStorage();
17015: }
17016: /**
17017: *
17018: *
17019: * @static
17020: */
17021: public static function setStorage($storage)
17022: {
17023: /** @var \Clockwork\Clockwork $instance */
17024: return $instance->setStorage($storage);
17025: }
17026: /**
17027: *
17028: *
17029: * @static
17030: */
17031: public static function getAuthenticator()
17032: {
17033: /** @var \Clockwork\Clockwork $instance */
17034: return $instance->getAuthenticator();
17035: }
17036: /**
17037: *
17038: *
17039: * @static
17040: */
17041: public static function setAuthenticator($authenticator)
17042: {
17043: /** @var \Clockwork\Clockwork $instance */
17044: return $instance->setAuthenticator($authenticator);
17045: }
17046:
17047: }
17048:
17049: }
17050:
17051: namespace Jenssegers\Agent\Facades {
17052: /**
17053: *
17054: *
17055: */
17056: class Agent {
17057: /**
17058: * Get all detection rules. These rules include the additional
17059: * platforms and browsers and utilities.
17060: *
17061: * @return array
17062: * @static
17063: */
17064: public static function getDetectionRulesExtended()
17065: {
17066: return \Jenssegers\Agent\Agent::getDetectionRulesExtended();
17067: }
17068: /**
17069: *
17070: *
17071: * @static
17072: */
17073: public static function getRules()
17074: {
17075: /** @var \Jenssegers\Agent\Agent $instance */
17076: return $instance->getRules();
17077: }
17078: /**
17079: *
17080: *
17081: * @return \Jaybizzle\CrawlerDetect\CrawlerDetect
17082: * @static
17083: */
17084: public static function getCrawlerDetect()
17085: {
17086: /** @var \Jenssegers\Agent\Agent $instance */
17087: return $instance->getCrawlerDetect();
17088: }
17089: /**
17090: *
17091: *
17092: * @static
17093: */
17094: public static function getBrowsers()
17095: {
17096: return \Jenssegers\Agent\Agent::getBrowsers();
17097: }
17098: /**
17099: *
17100: *
17101: * @static
17102: */
17103: public static function getOperatingSystems()
17104: {
17105: return \Jenssegers\Agent\Agent::getOperatingSystems();
17106: }
17107: /**
17108: *
17109: *
17110: * @static
17111: */
17112: public static function getPlatforms()
17113: {
17114: return \Jenssegers\Agent\Agent::getPlatforms();
17115: }
17116: /**
17117: *
17118: *
17119: * @static
17120: */
17121: public static function getDesktopDevices()
17122: {
17123: return \Jenssegers\Agent\Agent::getDesktopDevices();
17124: }
17125: /**
17126: *
17127: *
17128: * @static
17129: */
17130: public static function getProperties()
17131: {
17132: return \Jenssegers\Agent\Agent::getProperties();
17133: }
17134: /**
17135: * Get accept languages.
17136: *
17137: * @param string $acceptLanguage
17138: * @return array
17139: * @static
17140: */
17141: public static function languages($acceptLanguage = null)
17142: {
17143: /** @var \Jenssegers\Agent\Agent $instance */
17144: return $instance->languages($acceptLanguage);
17145: }
17146: /**
17147: * Get the browser name.
17148: *
17149: * @param string|null $userAgent
17150: * @return string|bool
17151: * @static
17152: */
17153: public static function browser($userAgent = null)
17154: {
17155: /** @var \Jenssegers\Agent\Agent $instance */
17156: return $instance->browser($userAgent);
17157: }
17158: /**
17159: * Get the platform name.
17160: *
17161: * @param string|null $userAgent
17162: * @return string|bool
17163: * @static
17164: */
17165: public static function platform($userAgent = null)
17166: {
17167: /** @var \Jenssegers\Agent\Agent $instance */
17168: return $instance->platform($userAgent);
17169: }
17170: /**
17171: * Get the device name.
17172: *
17173: * @param string|null $userAgent
17174: * @return string|bool
17175: * @static
17176: */
17177: public static function device($userAgent = null)
17178: {
17179: /** @var \Jenssegers\Agent\Agent $instance */
17180: return $instance->device($userAgent);
17181: }
17182: /**
17183: * Check if the device is a desktop computer.
17184: *
17185: * @param string|null $userAgent deprecated
17186: * @param array $httpHeaders deprecated
17187: * @return bool
17188: * @static
17189: */
17190: public static function isDesktop($userAgent = null, $httpHeaders = null)
17191: {
17192: /** @var \Jenssegers\Agent\Agent $instance */
17193: return $instance->isDesktop($userAgent, $httpHeaders);
17194: }
17195: /**
17196: * Check if the device is a mobile phone.
17197: *
17198: * @param string|null $userAgent deprecated
17199: * @param array $httpHeaders deprecated
17200: * @return bool
17201: * @static
17202: */
17203: public static function isPhone($userAgent = null, $httpHeaders = null)
17204: {
17205: /** @var \Jenssegers\Agent\Agent $instance */
17206: return $instance->isPhone($userAgent, $httpHeaders);
17207: }
17208: /**
17209: * Get the robot name.
17210: *
17211: * @param string|null $userAgent
17212: * @return string|bool
17213: * @static
17214: */
17215: public static function robot($userAgent = null)
17216: {
17217: /** @var \Jenssegers\Agent\Agent $instance */
17218: return $instance->robot($userAgent);
17219: }
17220: /**
17221: * Check if device is a robot.
17222: *
17223: * @param string|null $userAgent
17224: * @return bool
17225: * @static
17226: */
17227: public static function isRobot($userAgent = null)
17228: {
17229: /** @var \Jenssegers\Agent\Agent $instance */
17230: return $instance->isRobot($userAgent);
17231: }
17232: /**
17233: * Get the device type
17234: *
17235: * @param null $userAgent
17236: * @param null $httpHeaders
17237: * @return string
17238: * @static
17239: */
17240: public static function deviceType($userAgent = null, $httpHeaders = null)
17241: {
17242: /** @var \Jenssegers\Agent\Agent $instance */
17243: return $instance->deviceType($userAgent, $httpHeaders);
17244: }
17245: /**
17246: *
17247: *
17248: * @static
17249: */
17250: public static function version($propertyName, $type = 'text')
17251: {
17252: /** @var \Jenssegers\Agent\Agent $instance */
17253: return $instance->version($propertyName, $type);
17254: }
17255: /**
17256: * Get the current script version.
17257: *
17258: * This is useful for the demo.php file,
17259: * so people can check on what version they are testing
17260: * for mobile devices.
17261: *
17262: * @return string The version number in semantic version format.
17263: * @static
17264: */
17265: public static function getScriptVersion()
17266: { //Method inherited from \Mobile_Detect
17267: return \Jenssegers\Agent\Agent::getScriptVersion();
17268: }
17269: /**
17270: * Set the HTTP Headers. Must be PHP-flavored. This method will reset existing headers.
17271: *
17272: * @param array $httpHeaders The headers to set. If null, then using PHP's _SERVER to extract
17273: * the headers. The default null is left for backwards compatibility.
17274: * @static
17275: */
17276: public static function setHttpHeaders($httpHeaders = null)
17277: { //Method inherited from \Mobile_Detect
17278: /** @var \Jenssegers\Agent\Agent $instance */
17279: return $instance->setHttpHeaders($httpHeaders);
17280: }
17281: /**
17282: * Retrieves the HTTP headers.
17283: *
17284: * @return array
17285: * @static
17286: */
17287: public static function getHttpHeaders()
17288: { //Method inherited from \Mobile_Detect
17289: /** @var \Jenssegers\Agent\Agent $instance */
17290: return $instance->getHttpHeaders();
17291: }
17292: /**
17293: * Retrieves a particular header. If it doesn't exist, no exception/error is caused.
17294: *
17295: * Simply null is returned.
17296: *
17297: * @param string $header The name of the header to retrieve. Can be HTTP compliant such as
17298: * "User-Agent" or "X-Device-User-Agent" or can be php-esque with the
17299: * all-caps, HTTP_ prefixed, underscore seperated awesomeness.
17300: * @return string|null The value of the header.
17301: * @static
17302: */
17303: public static function getHttpHeader($header)
17304: { //Method inherited from \Mobile_Detect
17305: /** @var \Jenssegers\Agent\Agent $instance */
17306: return $instance->getHttpHeader($header);
17307: }
17308: /**
17309: *
17310: *
17311: * @static
17312: */
17313: public static function getMobileHeaders()
17314: { //Method inherited from \Mobile_Detect
17315: /** @var \Jenssegers\Agent\Agent $instance */
17316: return $instance->getMobileHeaders();
17317: }
17318: /**
17319: * Get all possible HTTP headers that
17320: * can contain the User-Agent string.
17321: *
17322: * @return array List of HTTP headers.
17323: * @static
17324: */
17325: public static function getUaHttpHeaders()
17326: { //Method inherited from \Mobile_Detect
17327: /** @var \Jenssegers\Agent\Agent $instance */
17328: return $instance->getUaHttpHeaders();
17329: }
17330: /**
17331: * Set CloudFront headers
17332: * http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/header-caching.html#header-caching-web-device
17333: *
17334: * @param array $cfHeaders List of HTTP headers
17335: * @return boolean If there were CloudFront headers to be set
17336: * @static
17337: */
17338: public static function setCfHeaders($cfHeaders = null)
17339: { //Method inherited from \Mobile_Detect
17340: /** @var \Jenssegers\Agent\Agent $instance */
17341: return $instance->setCfHeaders($cfHeaders);
17342: }
17343: /**
17344: * Retrieves the cloudfront headers.
17345: *
17346: * @return array
17347: * @static
17348: */
17349: public static function getCfHeaders()
17350: { //Method inherited from \Mobile_Detect
17351: /** @var \Jenssegers\Agent\Agent $instance */
17352: return $instance->getCfHeaders();
17353: }
17354: /**
17355: * Set the User-Agent to be used.
17356: *
17357: * @param string $userAgent The user agent string to set.
17358: * @return string|null
17359: * @static
17360: */
17361: public static function setUserAgent($userAgent = null)
17362: { //Method inherited from \Mobile_Detect
17363: /** @var \Jenssegers\Agent\Agent $instance */
17364: return $instance->setUserAgent($userAgent);
17365: }
17366: /**
17367: * Retrieve the User-Agent.
17368: *
17369: * @return string|null The user agent if it's set.
17370: * @static
17371: */
17372: public static function getUserAgent()
17373: { //Method inherited from \Mobile_Detect
17374: /** @var \Jenssegers\Agent\Agent $instance */
17375: return $instance->getUserAgent();
17376: }
17377: /**
17378: * Set the detection type. Must be one of self::DETECTION_TYPE_MOBILE or
17379: * self::DETECTION_TYPE_EXTENDED. Otherwise, nothing is set.
17380: *
17381: * @deprecated since version 2.6.9
17382: * @param string $type The type. Must be a self::DETECTION_TYPE_* constant. The default
17383: * parameter is null which will default to self::DETECTION_TYPE_MOBILE.
17384: * @static
17385: */
17386: public static function setDetectionType($type = null)
17387: { //Method inherited from \Mobile_Detect
17388: /** @var \Jenssegers\Agent\Agent $instance */
17389: return $instance->setDetectionType($type);
17390: }
17391: /**
17392: *
17393: *
17394: * @static
17395: */
17396: public static function getMatchingRegex()
17397: { //Method inherited from \Mobile_Detect
17398: /** @var \Jenssegers\Agent\Agent $instance */
17399: return $instance->getMatchingRegex();
17400: }
17401: /**
17402: *
17403: *
17404: * @static
17405: */
17406: public static function getMatchesArray()
17407: { //Method inherited from \Mobile_Detect
17408: /** @var \Jenssegers\Agent\Agent $instance */
17409: return $instance->getMatchesArray();
17410: }
17411: /**
17412: * Retrieve the list of known phone devices.
17413: *
17414: * @return array List of phone devices.
17415: * @static
17416: */
17417: public static function getPhoneDevices()
17418: { //Method inherited from \Mobile_Detect
17419: return \Jenssegers\Agent\Agent::getPhoneDevices();
17420: }
17421: /**
17422: * Retrieve the list of known tablet devices.
17423: *
17424: * @return array List of tablet devices.
17425: * @static
17426: */
17427: public static function getTabletDevices()
17428: { //Method inherited from \Mobile_Detect
17429: return \Jenssegers\Agent\Agent::getTabletDevices();
17430: }
17431: /**
17432: * Alias for getBrowsers() method.
17433: *
17434: * @return array List of user agents.
17435: * @static
17436: */
17437: public static function getUserAgents()
17438: { //Method inherited from \Mobile_Detect
17439: return \Jenssegers\Agent\Agent::getUserAgents();
17440: }
17441: /**
17442: * Retrieve the list of known utilities.
17443: *
17444: * @return array List of utilities.
17445: * @static
17446: */
17447: public static function getUtilities()
17448: { //Method inherited from \Mobile_Detect
17449: return \Jenssegers\Agent\Agent::getUtilities();
17450: }
17451: /**
17452: * Method gets the mobile detection rules. This method is used for the magic methods $detect->is*().
17453: *
17454: * @deprecated since version 2.6.9
17455: * @return array All the rules (but not extended).
17456: * @static
17457: */
17458: public static function getMobileDetectionRules()
17459: { //Method inherited from \Mobile_Detect
17460: return \Jenssegers\Agent\Agent::getMobileDetectionRules();
17461: }
17462: /**
17463: * Method gets the mobile detection rules + utilities.
17464: *
17465: * The reason this is separate is because utilities rules
17466: * don't necessary imply mobile. This method is used inside
17467: * the new $detect->is('stuff') method.
17468: *
17469: * @deprecated since version 2.6.9
17470: * @return array All the rules + extended.
17471: * @static
17472: */
17473: public static function getMobileDetectionRulesExtended()
17474: { //Method inherited from \Mobile_Detect
17475: /** @var \Jenssegers\Agent\Agent $instance */
17476: return $instance->getMobileDetectionRulesExtended();
17477: }
17478: /**
17479: * Check the HTTP headers for signs of mobile.
17480: *
17481: * This is the fastest mobile check possible; it's used
17482: * inside isMobile() method.
17483: *
17484: * @return bool
17485: * @static
17486: */
17487: public static function checkHttpHeadersForMobile()
17488: { //Method inherited from \Mobile_Detect
17489: /** @var \Jenssegers\Agent\Agent $instance */
17490: return $instance->checkHttpHeadersForMobile();
17491: }
17492: /**
17493: * Check if the device is mobile.
17494: *
17495: * Returns true if any type of mobile device detected, including special ones
17496: *
17497: * @param null $userAgent deprecated
17498: * @param null $httpHeaders deprecated
17499: * @return bool
17500: * @static
17501: */
17502: public static function isMobile($userAgent = null, $httpHeaders = null)
17503: { //Method inherited from \Mobile_Detect
17504: /** @var \Jenssegers\Agent\Agent $instance */
17505: return $instance->isMobile($userAgent, $httpHeaders);
17506: }
17507: /**
17508: * Check if the device is a tablet.
17509: *
17510: * Return true if any type of tablet device is detected.
17511: *
17512: * @param string $userAgent deprecated
17513: * @param array $httpHeaders deprecated
17514: * @return bool
17515: * @static
17516: */
17517: public static function isTablet($userAgent = null, $httpHeaders = null)
17518: { //Method inherited from \Mobile_Detect
17519: /** @var \Jenssegers\Agent\Agent $instance */
17520: return $instance->isTablet($userAgent, $httpHeaders);
17521: }
17522: /**
17523: * This method checks for a certain property in the
17524: * userAgent.
17525: *
17526: * @todo : The httpHeaders part is not yet used.
17527: * @param string $key
17528: * @param string $userAgent deprecated
17529: * @param string $httpHeaders deprecated
17530: * @return bool|int|null
17531: * @static
17532: */
17533: public static function is($key, $userAgent = null, $httpHeaders = null)
17534: { //Method inherited from \Mobile_Detect
17535: /** @var \Jenssegers\Agent\Agent $instance */
17536: return $instance->is($key, $userAgent, $httpHeaders);
17537: }
17538: /**
17539: * Some detection rules are relative (not standard),
17540: * because of the diversity of devices, vendors and
17541: * their conventions in representing the User-Agent or
17542: * the HTTP headers.
17543: *
17544: * This method will be used to check custom regexes against
17545: * the User-Agent string.
17546: *
17547: * @param $regex
17548: * @param string $userAgent
17549: * @return bool
17550: * @todo : search in the HTTP headers too.
17551: * @static
17552: */
17553: public static function match($regex, $userAgent = null)
17554: { //Method inherited from \Mobile_Detect
17555: /** @var \Jenssegers\Agent\Agent $instance */
17556: return $instance->match($regex, $userAgent);
17557: }
17558: /**
17559: * Prepare the version number.
17560: *
17561: * @todo Remove the error supression from str_replace() call.
17562: * @param string $ver The string version, like "2.6.21.2152";
17563: * @return float
17564: * @static
17565: */
17566: public static function prepareVersionNo($ver)
17567: { //Method inherited from \Mobile_Detect
17568: /** @var \Jenssegers\Agent\Agent $instance */
17569: return $instance->prepareVersionNo($ver);
17570: }
17571: /**
17572: * Retrieve the mobile grading, using self::MOBILE_GRADE_* constants.
17573: *
17574: * @deprecated This is no longer being maintained, it was an experiment at the time.
17575: * @return string One of the self::MOBILE_GRADE_* constants.
17576: * @static
17577: */
17578: public static function mobileGrade()
17579: { //Method inherited from \Mobile_Detect
17580: /** @var \Jenssegers\Agent\Agent $instance */
17581: return $instance->mobileGrade();
17582: }
17583:
17584: }
17585:
17586: }
17587:
17588: namespace Livewire {
17589: /**
17590: *
17591: *
17592: * @see \Livewire\LivewireManager
17593: */
17594: class Livewire {
17595: /**
17596: *
17597: *
17598: * @static
17599: */
17600: public static function component($alias, $viewClass = null)
17601: {
17602: /** @var \Livewire\LivewireManager $instance */
17603: return $instance->component($alias, $viewClass);
17604: }
17605: /**
17606: *
17607: *
17608: * @static
17609: */
17610: public static function getAlias($class, $default = null)
17611: {
17612: /** @var \Livewire\LivewireManager $instance */
17613: return $instance->getAlias($class, $default);
17614: }
17615: /**
17616: *
17617: *
17618: * @static
17619: */
17620: public static function getComponentAliases()
17621: {
17622: /** @var \Livewire\LivewireManager $instance */
17623: return $instance->getComponentAliases();
17624: }
17625: /**
17626: *
17627: *
17628: * @static
17629: */
17630: public static function getClass($alias)
17631: {
17632: /** @var \Livewire\LivewireManager $instance */
17633: return $instance->getClass($alias);
17634: }
17635: /**
17636: *
17637: *
17638: * @static
17639: */
17640: public static function getInstance($component, $id)
17641: {
17642: /** @var \Livewire\LivewireManager $instance */
17643: return $instance->getInstance($component, $id);
17644: }
17645: /**
17646: *
17647: *
17648: * @static
17649: */
17650: public static function mount($name, $params = [])
17651: {
17652: /** @var \Livewire\LivewireManager $instance */
17653: return $instance->mount($name, $params);
17654: }
17655: /**
17656: *
17657: *
17658: * @static
17659: */
17660: public static function dummyMount($id, $tagName)
17661: {
17662: /** @var \Livewire\LivewireManager $instance */
17663: return $instance->dummyMount($id, $tagName);
17664: }
17665: /**
17666: *
17667: *
17668: * @static
17669: */
17670: public static function test($name, $params = [])
17671: {
17672: /** @var \Livewire\LivewireManager $instance */
17673: return $instance->test($name, $params);
17674: }
17675: /**
17676: *
17677: *
17678: * @static
17679: */
17680: public static function visit($browser, $class, $queryString = '')
17681: {
17682: /** @var \Livewire\LivewireManager $instance */
17683: return $instance->visit($browser, $class, $queryString);
17684: }
17685: /**
17686: *
17687: *
17688: * @static
17689: */
17690: public static function actingAs($user, $driver = null)
17691: {
17692: /** @var \Livewire\LivewireManager $instance */
17693: return $instance->actingAs($user, $driver);
17694: }
17695: /**
17696: *
17697: *
17698: * @static
17699: */
17700: public static function addPersistentMiddleware($middleware)
17701: {
17702: /** @var \Livewire\LivewireManager $instance */
17703: return $instance->addPersistentMiddleware($middleware);
17704: }
17705: /**
17706: *
17707: *
17708: * @static
17709: */
17710: public static function setPersistentMiddleware($middleware)
17711: {
17712: /** @var \Livewire\LivewireManager $instance */
17713: return $instance->setPersistentMiddleware($middleware);
17714: }
17715: /**
17716: *
17717: *
17718: * @static
17719: */
17720: public static function getPersistentMiddleware()
17721: {
17722: /** @var \Livewire\LivewireManager $instance */
17723: return $instance->getPersistentMiddleware();
17724: }
17725: /**
17726: *
17727: *
17728: * @static
17729: */
17730: public static function styles($options = [])
17731: {
17732: /** @var \Livewire\LivewireManager $instance */
17733: return $instance->styles($options);
17734: }
17735: /**
17736: *
17737: *
17738: * @static
17739: */
17740: public static function scripts($options = [])
17741: {
17742: /** @var \Livewire\LivewireManager $instance */
17743: return $instance->scripts($options);
17744: }
17745: /**
17746: *
17747: *
17748: * @static
17749: */
17750: public static function isLivewireRequest()
17751: {
17752: /** @var \Livewire\LivewireManager $instance */
17753: return $instance->isLivewireRequest();
17754: }
17755: /**
17756: *
17757: *
17758: * @static
17759: */
17760: public static function isDefinitelyLivewireRequest()
17761: {
17762: /** @var \Livewire\LivewireManager $instance */
17763: return $instance->isDefinitelyLivewireRequest();
17764: }
17765: /**
17766: *
17767: *
17768: * @static
17769: */
17770: public static function isProbablyLivewireRequest()
17771: {
17772: /** @var \Livewire\LivewireManager $instance */
17773: return $instance->isProbablyLivewireRequest();
17774: }
17775: /**
17776: *
17777: *
17778: * @static
17779: */
17780: public static function originalUrl()
17781: {
17782: /** @var \Livewire\LivewireManager $instance */
17783: return $instance->originalUrl();
17784: }
17785: /**
17786: *
17787: *
17788: * @static
17789: */
17790: public static function originalPath()
17791: {
17792: /** @var \Livewire\LivewireManager $instance */
17793: return $instance->originalPath();
17794: }
17795: /**
17796: *
17797: *
17798: * @static
17799: */
17800: public static function originalMethod()
17801: {
17802: /** @var \Livewire\LivewireManager $instance */
17803: return $instance->originalMethod();
17804: }
17805: /**
17806: *
17807: *
17808: * @static
17809: */
17810: public static function getRootElementTagName($dom)
17811: {
17812: /** @var \Livewire\LivewireManager $instance */
17813: return $instance->getRootElementTagName($dom);
17814: }
17815: /**
17816: *
17817: *
17818: * @static
17819: */
17820: public static function dispatch($event, ...$params)
17821: {
17822: /** @var \Livewire\LivewireManager $instance */
17823: return $instance->dispatch($event, ...$params);
17824: }
17825: /**
17826: *
17827: *
17828: * @static
17829: */
17830: public static function listen($event, $callback)
17831: {
17832: /** @var \Livewire\LivewireManager $instance */
17833: return $instance->listen($event, $callback);
17834: }
17835: /**
17836: *
17837: *
17838: * @static
17839: */
17840: public static function isOnVapor()
17841: {
17842: /** @var \Livewire\LivewireManager $instance */
17843: return $instance->isOnVapor();
17844: }
17845: /**
17846: *
17847: *
17848: * @static
17849: */
17850: public static function isRunningServerless()
17851: {
17852: /** @var \Livewire\LivewireManager $instance */
17853: return $instance->isRunningServerless();
17854: }
17855: /**
17856: *
17857: *
17858: * @static
17859: */
17860: public static function withQueryParams($queryParams)
17861: {
17862: /** @var \Livewire\LivewireManager $instance */
17863: return $instance->withQueryParams($queryParams);
17864: }
17865: /**
17866: *
17867: *
17868: * @static
17869: */
17870: public static function setBackButtonCache()
17871: {
17872: /** @var \Livewire\LivewireManager $instance */
17873: return $instance->setBackButtonCache();
17874: }
17875: /**
17876: *
17877: *
17878: * @static
17879: */
17880: public static function disableBackButtonCache()
17881: {
17882: /** @var \Livewire\LivewireManager $instance */
17883: return $instance->disableBackButtonCache();
17884: }
17885: /**
17886: *
17887: *
17888: * @static
17889: */
17890: public static function enableBackButtonCache()
17891: {
17892: /** @var \Livewire\LivewireManager $instance */
17893: return $instance->enableBackButtonCache();
17894: }
17895: /**
17896: *
17897: *
17898: * @static
17899: */
17900: public static function shouldDisableBackButtonCache()
17901: {
17902: /** @var \Livewire\LivewireManager $instance */
17903: return $instance->shouldDisableBackButtonCache();
17904: }
17905: /**
17906: *
17907: *
17908: * @static
17909: */
17910: public static function flushState()
17911: {
17912: /** @var \Livewire\LivewireManager $instance */
17913: return $instance->flushState();
17914: }
17915:
17916: }
17917:
17918: }
17919:
17920: namespace Lorisleiva\Actions\Facades {
17921: /**
17922: *
17923: *
17924: * @see ActionManager
17925: */
17926: class Actions {
17927: /**
17928: *
17929: *
17930: * @static
17931: */
17932: public static function setDesignPatterns($designPatterns)
17933: {
17934: /** @var \Lorisleiva\Actions\ActionManager $instance */
17935: return $instance->setDesignPatterns($designPatterns);
17936: }
17937: /**
17938: *
17939: *
17940: * @static
17941: */
17942: public static function getDesignPatterns()
17943: {
17944: /** @var \Lorisleiva\Actions\ActionManager $instance */
17945: return $instance->getDesignPatterns();
17946: }
17947: /**
17948: *
17949: *
17950: * @static
17951: */
17952: public static function getDesignPatternsMatching($usedTraits)
17953: {
17954: /** @var \Lorisleiva\Actions\ActionManager $instance */
17955: return $instance->getDesignPatternsMatching($usedTraits);
17956: }
17957: /**
17958: *
17959: *
17960: * @static
17961: */
17962: public static function extend($abstract)
17963: {
17964: /** @var \Lorisleiva\Actions\ActionManager $instance */
17965: return $instance->extend($abstract);
17966: }
17967: /**
17968: *
17969: *
17970: * @static
17971: */
17972: public static function isExtending($abstract)
17973: {
17974: /** @var \Lorisleiva\Actions\ActionManager $instance */
17975: return $instance->isExtending($abstract);
17976: }
17977: /**
17978: *
17979: *
17980: * @static
17981: */
17982: public static function shouldExtend($abstract)
17983: {
17984: /** @var \Lorisleiva\Actions\ActionManager $instance */
17985: return $instance->shouldExtend($abstract);
17986: }
17987: /**
17988: *
17989: *
17990: * @static
17991: */
17992: public static function identifyAndDecorate($instance, $limit = 10)
17993: {
17994: /** @var \Lorisleiva\Actions\ActionManager $instance */
17995: return $instance->identifyAndDecorate($instance, $limit);
17996: }
17997: /**
17998: *
17999: *
18000: * @static
18001: */
18002: public static function identifyFromBacktrace($usedTraits, $limit = 10, $frame = null)
18003: {
18004: /** @var \Lorisleiva\Actions\ActionManager $instance */
18005: return $instance->identifyFromBacktrace($usedTraits, $limit, $frame);
18006: }
18007: /**
18008: *
18009: *
18010: * @static
18011: */
18012: public static function registerRoutes($paths = 'app/Actions')
18013: {
18014: /** @var \Lorisleiva\Actions\ActionManager $instance */
18015: return $instance->registerRoutes($paths);
18016: }
18017: /**
18018: *
18019: *
18020: * @static
18021: */
18022: public static function registerCommands($paths = 'app/Actions')
18023: {
18024: /** @var \Lorisleiva\Actions\ActionManager $instance */
18025: return $instance->registerCommands($paths);
18026: }
18027: /**
18028: *
18029: *
18030: * @static
18031: */
18032: public static function registerRoutesForAction($className)
18033: {
18034: /** @var \Lorisleiva\Actions\ActionManager $instance */
18035: return $instance->registerRoutesForAction($className);
18036: }
18037: /**
18038: *
18039: *
18040: * @static
18041: */
18042: public static function registerCommandsForAction($className)
18043: {
18044: /** @var \Lorisleiva\Actions\ActionManager $instance */
18045: return $instance->registerCommandsForAction($className);
18046: }
18047:
18048: }
18049:
18050: }
18051:
18052: namespace Lorisleiva\Lody {
18053: /**
18054: *
18055: *
18056: * @see LodyManager
18057: */
18058: class Lody {
18059: /**
18060: *
18061: *
18062: * @static
18063: */
18064: public static function classes($paths, $recursive = true)
18065: {
18066: /** @var \Lorisleiva\Lody\LodyManager $instance */
18067: return $instance->classes($paths, $recursive);
18068: }
18069: /**
18070: *
18071: *
18072: * @static
18073: */
18074: public static function classesFromFinder($finder)
18075: {
18076: /** @var \Lorisleiva\Lody\LodyManager $instance */
18077: return $instance->classesFromFinder($finder);
18078: }
18079: /**
18080: *
18081: *
18082: * @static
18083: */
18084: public static function files($paths, $recursive = true, $hidden = false)
18085: {
18086: /** @var \Lorisleiva\Lody\LodyManager $instance */
18087: return $instance->files($paths, $recursive, $hidden);
18088: }
18089: /**
18090: *
18091: *
18092: * @static
18093: */
18094: public static function filesFromFinder($finder)
18095: {
18096: /** @var \Lorisleiva\Lody\LodyManager $instance */
18097: return $instance->filesFromFinder($finder);
18098: }
18099: /**
18100: *
18101: *
18102: * @static
18103: */
18104: public static function resolvePathUsing($callback)
18105: {
18106: /** @var \Lorisleiva\Lody\LodyManager $instance */
18107: return $instance->resolvePathUsing($callback);
18108: }
18109: /**
18110: *
18111: *
18112: * @static
18113: */
18114: public static function resolvePath($path)
18115: {
18116: /** @var \Lorisleiva\Lody\LodyManager $instance */
18117: return $instance->resolvePath($path);
18118: }
18119: /**
18120: *
18121: *
18122: * @static
18123: */
18124: public static function resolveClassnameUsing($callback)
18125: {
18126: /** @var \Lorisleiva\Lody\LodyManager $instance */
18127: return $instance->resolveClassnameUsing($callback);
18128: }
18129: /**
18130: *
18131: *
18132: * @static
18133: */
18134: public static function resolveClassname($file)
18135: {
18136: /** @var \Lorisleiva\Lody\LodyManager $instance */
18137: return $instance->resolveClassname($file);
18138: }
18139: /**
18140: *
18141: *
18142: * @static
18143: */
18144: public static function setBasePath($basePath)
18145: {
18146: /** @var \Lorisleiva\Lody\LodyManager $instance */
18147: return $instance->setBasePath($basePath);
18148: }
18149: /**
18150: *
18151: *
18152: * @static
18153: */
18154: public static function getBasePath($path = '')
18155: {
18156: /** @var \Lorisleiva\Lody\LodyManager $instance */
18157: return $instance->getBasePath($path);
18158: }
18159: /**
18160: *
18161: *
18162: * @static
18163: */
18164: public static function setAutoloadPath($autoloadPath)
18165: {
18166: /** @var \Lorisleiva\Lody\LodyManager $instance */
18167: return $instance->setAutoloadPath($autoloadPath);
18168: }
18169: /**
18170: *
18171: *
18172: * @static
18173: */
18174: public static function getAutoloadPath()
18175: {
18176: /** @var \Lorisleiva\Lody\LodyManager $instance */
18177: return $instance->getAutoloadPath();
18178: }
18179:
18180: }
18181:
18182: }
18183:
18184: namespace BeyondCode\ServerTiming\Facades {
18185: /**
18186: *
18187: *
18188: */
18189: class ServerTiming {
18190: /**
18191: *
18192: *
18193: * @static
18194: */
18195: public static function addMetric($metric)
18196: {
18197: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18198: return $instance->addMetric($metric);
18199: }
18200: /**
18201: *
18202: *
18203: * @static
18204: */
18205: public static function addMessage($message)
18206: {
18207: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18208: return $instance->addMessage($message);
18209: }
18210: /**
18211: *
18212: *
18213: * @static
18214: */
18215: public static function hasStartedEvent($key)
18216: {
18217: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18218: return $instance->hasStartedEvent($key);
18219: }
18220: /**
18221: *
18222: *
18223: * @static
18224: */
18225: public static function measure($key)
18226: {
18227: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18228: return $instance->measure($key);
18229: }
18230: /**
18231: *
18232: *
18233: * @static
18234: */
18235: public static function start($key)
18236: {
18237: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18238: return $instance->start($key);
18239: }
18240: /**
18241: *
18242: *
18243: * @static
18244: */
18245: public static function stop($key)
18246: {
18247: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18248: return $instance->stop($key);
18249: }
18250: /**
18251: *
18252: *
18253: * @static
18254: */
18255: public static function stopAllUnfinishedEvents()
18256: {
18257: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18258: return $instance->stopAllUnfinishedEvents();
18259: }
18260: /**
18261: *
18262: *
18263: * @static
18264: */
18265: public static function setDuration($key, $duration)
18266: {
18267: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18268: return $instance->setDuration($key, $duration);
18269: }
18270: /**
18271: *
18272: *
18273: * @static
18274: */
18275: public static function getDuration($key)
18276: {
18277: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18278: return $instance->getDuration($key);
18279: }
18280: /**
18281: *
18282: *
18283: * @return \BeyondCode\ServerTiming\array<string, int|float|null>
18284: * @static
18285: */
18286: public static function events()
18287: {
18288: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18289: return $instance->events();
18290: }
18291: /**
18292: *
18293: *
18294: * @static
18295: */
18296: public static function reset()
18297: {
18298: /** @var \BeyondCode\ServerTiming\ServerTiming $instance */
18299: return $instance->reset();
18300: }
18301:
18302: }
18303:
18304: }
18305:
18306: namespace Spatie\LaravelIgnition\Facades {
18307: /**
18308: *
18309: *
18310: * @see \Spatie\FlareClient\Flare
18311: */
18312: class Flare {
18313: /**
18314: *
18315: *
18316: * @static
18317: */
18318: public static function make($apiKey = null, $contextDetector = null)
18319: {
18320: return \Spatie\FlareClient\Flare::make($apiKey, $contextDetector);
18321: }
18322: /**
18323: *
18324: *
18325: * @static
18326: */
18327: public static function setApiToken($apiToken)
18328: {
18329: /** @var \Spatie\FlareClient\Flare $instance */
18330: return $instance->setApiToken($apiToken);
18331: }
18332: /**
18333: *
18334: *
18335: * @static
18336: */
18337: public static function apiTokenSet()
18338: {
18339: /** @var \Spatie\FlareClient\Flare $instance */
18340: return $instance->apiTokenSet();
18341: }
18342: /**
18343: *
18344: *
18345: * @static
18346: */
18347: public static function setBaseUrl($baseUrl)
18348: {
18349: /** @var \Spatie\FlareClient\Flare $instance */
18350: return $instance->setBaseUrl($baseUrl);
18351: }
18352: /**
18353: *
18354: *
18355: * @static
18356: */
18357: public static function setStage($stage)
18358: {
18359: /** @var \Spatie\FlareClient\Flare $instance */
18360: return $instance->setStage($stage);
18361: }
18362: /**
18363: *
18364: *
18365: * @static
18366: */
18367: public static function sendReportsImmediately()
18368: {
18369: /** @var \Spatie\FlareClient\Flare $instance */
18370: return $instance->sendReportsImmediately();
18371: }
18372: /**
18373: *
18374: *
18375: * @static
18376: */
18377: public static function determineVersionUsing($determineVersionCallable)
18378: {
18379: /** @var \Spatie\FlareClient\Flare $instance */
18380: return $instance->determineVersionUsing($determineVersionCallable);
18381: }
18382: /**
18383: *
18384: *
18385: * @static
18386: */
18387: public static function reportErrorLevels($reportErrorLevels)
18388: {
18389: /** @var \Spatie\FlareClient\Flare $instance */
18390: return $instance->reportErrorLevels($reportErrorLevels);
18391: }
18392: /**
18393: *
18394: *
18395: * @static
18396: */
18397: public static function filterExceptionsUsing($filterExceptionsCallable)
18398: {
18399: /** @var \Spatie\FlareClient\Flare $instance */
18400: return $instance->filterExceptionsUsing($filterExceptionsCallable);
18401: }
18402: /**
18403: *
18404: *
18405: * @static
18406: */
18407: public static function version()
18408: {
18409: /** @var \Spatie\FlareClient\Flare $instance */
18410: return $instance->version();
18411: }
18412: /**
18413: *
18414: *
18415: * @return \Spatie\FlareClient\array<int, FlareMiddleware|class-string<FlareMiddleware>>
18416: * @static
18417: */
18418: public static function getMiddleware()
18419: {
18420: /** @var \Spatie\FlareClient\Flare $instance */
18421: return $instance->getMiddleware();
18422: }
18423: /**
18424: *
18425: *
18426: * @static
18427: */
18428: public static function setContextProviderDetector($contextDetector)
18429: {
18430: /** @var \Spatie\FlareClient\Flare $instance */
18431: return $instance->setContextProviderDetector($contextDetector);
18432: }
18433: /**
18434: *
18435: *
18436: * @static
18437: */
18438: public static function setContainer($container)
18439: {
18440: /** @var \Spatie\FlareClient\Flare $instance */
18441: return $instance->setContainer($container);
18442: }
18443: /**
18444: *
18445: *
18446: * @static
18447: */
18448: public static function registerFlareHandlers()
18449: {
18450: /** @var \Spatie\FlareClient\Flare $instance */
18451: return $instance->registerFlareHandlers();
18452: }
18453: /**
18454: *
18455: *
18456: * @static
18457: */
18458: public static function registerExceptionHandler()
18459: {
18460: /** @var \Spatie\FlareClient\Flare $instance */
18461: return $instance->registerExceptionHandler();
18462: }
18463: /**
18464: *
18465: *
18466: * @static
18467: */
18468: public static function registerErrorHandler()
18469: {
18470: /** @var \Spatie\FlareClient\Flare $instance */
18471: return $instance->registerErrorHandler();
18472: }
18473: /**
18474: *
18475: *
18476: * @param \Spatie\FlareClient\FlareMiddleware\FlareMiddleware|\Spatie\FlareClient\array<FlareMiddleware>|\Spatie\FlareClient\class-string<FlareMiddleware> $middleware
18477: * @return \Spatie\FlareClient\Flare
18478: * @static
18479: */
18480: public static function registerMiddleware($middleware)
18481: {
18482: /** @var \Spatie\FlareClient\Flare $instance */
18483: return $instance->registerMiddleware($middleware);
18484: }
18485: /**
18486: *
18487: *
18488: * @return \Spatie\FlareClient\array<int,FlareMiddleware|\Spatie\FlareClient\class-string<FlareMiddleware>>
18489: * @static
18490: */
18491: public static function getMiddlewares()
18492: {
18493: /** @var \Spatie\FlareClient\Flare $instance */
18494: return $instance->getMiddlewares();
18495: }
18496: /**
18497: *
18498: *
18499: * @param string $name
18500: * @param string $messageLevel
18501: * @param \Spatie\FlareClient\array<int, mixed> $metaData
18502: * @return \Spatie\FlareClient\Flare
18503: * @static
18504: */
18505: public static function glow($name, $messageLevel = 'info', $metaData = [])
18506: {
18507: /** @var \Spatie\FlareClient\Flare $instance */
18508: return $instance->glow($name, $messageLevel, $metaData);
18509: }
18510: /**
18511: *
18512: *
18513: * @static
18514: */
18515: public static function handleException($throwable)
18516: {
18517: /** @var \Spatie\FlareClient\Flare $instance */
18518: return $instance->handleException($throwable);
18519: }
18520: /**
18521: *
18522: *
18523: * @return mixed
18524: * @static
18525: */
18526: public static function handleError($code, $message, $file = '', $line = 0)
18527: {
18528: /** @var \Spatie\FlareClient\Flare $instance */
18529: return $instance->handleError($code, $message, $file, $line);
18530: }
18531: /**
18532: *
18533: *
18534: * @static
18535: */
18536: public static function applicationPath($applicationPath)
18537: {
18538: /** @var \Spatie\FlareClient\Flare $instance */
18539: return $instance->applicationPath($applicationPath);
18540: }
18541: /**
18542: *
18543: *
18544: * @static
18545: */
18546: public static function report($throwable, $callback = null, $report = null)
18547: {
18548: /** @var \Spatie\FlareClient\Flare $instance */
18549: return $instance->report($throwable, $callback, $report);
18550: }
18551: /**
18552: *
18553: *
18554: * @static
18555: */
18556: public static function reportMessage($message, $logLevel, $callback = null)
18557: {
18558: /** @var \Spatie\FlareClient\Flare $instance */
18559: return $instance->reportMessage($message, $logLevel, $callback);
18560: }
18561: /**
18562: *
18563: *
18564: * @static
18565: */
18566: public static function sendTestReport($throwable)
18567: {
18568: /** @var \Spatie\FlareClient\Flare $instance */
18569: return $instance->sendTestReport($throwable);
18570: }
18571: /**
18572: *
18573: *
18574: * @static
18575: */
18576: public static function reset()
18577: {
18578: /** @var \Spatie\FlareClient\Flare $instance */
18579: return $instance->reset();
18580: }
18581: /**
18582: *
18583: *
18584: * @static
18585: */
18586: public static function anonymizeIp()
18587: {
18588: /** @var \Spatie\FlareClient\Flare $instance */
18589: return $instance->anonymizeIp();
18590: }
18591: /**
18592: *
18593: *
18594: * @param \Spatie\FlareClient\array<int, string> $fieldNames
18595: * @return \Spatie\FlareClient\Flare
18596: * @static
18597: */
18598: public static function censorRequestBodyFields($fieldNames)
18599: {
18600: /** @var \Spatie\FlareClient\Flare $instance */
18601: return $instance->censorRequestBodyFields($fieldNames);
18602: }
18603: /**
18604: *
18605: *
18606: * @static
18607: */
18608: public static function createReport($throwable)
18609: {
18610: /** @var \Spatie\FlareClient\Flare $instance */
18611: return $instance->createReport($throwable);
18612: }
18613: /**
18614: *
18615: *
18616: * @static
18617: */
18618: public static function createReportFromMessage($message, $logLevel)
18619: {
18620: /** @var \Spatie\FlareClient\Flare $instance */
18621: return $instance->createReportFromMessage($message, $logLevel);
18622: }
18623: /**
18624: *
18625: *
18626: * @static
18627: */
18628: public static function stage($stage)
18629: {
18630: /** @var \Spatie\FlareClient\Flare $instance */
18631: return $instance->stage($stage);
18632: }
18633: /**
18634: *
18635: *
18636: * @static
18637: */
18638: public static function messageLevel($messageLevel)
18639: {
18640: /** @var \Spatie\FlareClient\Flare $instance */
18641: return $instance->messageLevel($messageLevel);
18642: }
18643: /**
18644: *
18645: *
18646: * @param string $groupName
18647: * @param mixed $default
18648: * @return \Spatie\FlareClient\array<int, mixed>
18649: * @static
18650: */
18651: public static function getGroup($groupName = 'context', $default = [])
18652: {
18653: /** @var \Spatie\FlareClient\Flare $instance */
18654: return $instance->getGroup($groupName, $default);
18655: }
18656: /**
18657: *
18658: *
18659: * @static
18660: */
18661: public static function context($key, $value)
18662: {
18663: /** @var \Spatie\FlareClient\Flare $instance */
18664: return $instance->context($key, $value);
18665: }
18666: /**
18667: *
18668: *
18669: * @param string $groupName
18670: * @param \Spatie\FlareClient\array<string, mixed> $properties
18671: * @return \Spatie\FlareClient\Flare
18672: * @static
18673: */
18674: public static function group($groupName, $properties)
18675: {
18676: /** @var \Spatie\FlareClient\Flare $instance */
18677: return $instance->group($groupName, $properties);
18678: }
18679:
18680: }
18681:
18682: }
18683:
18684: namespace Illuminate\Filesystem {
18685: /**
18686: *
18687: *
18688: */
18689: class Filesystem {
18690: /**
18691: *
18692: *
18693: * @see \Blueprint\FileMixins::stub()
18694: * @param mixed $path
18695: * @static
18696: */
18697: public static function stub($path)
18698: {
18699: return \Illuminate\Filesystem\Filesystem::stub($path);
18700: }
18701:
18702: }
18703:
18704: }
18705:
18706: namespace Illuminate\Http {
18707: /**
18708: *
18709: *
18710: */
18711: class Request {
18712: /**
18713: *
18714: *
18715: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
18716: * @param array $rules
18717: * @param mixed $params
18718: * @static
18719: */
18720: public static function validate($rules, ...$params)
18721: {
18722: return \Illuminate\Http\Request::validate($rules, ...$params);
18723: }
18724: /**
18725: *
18726: *
18727: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestValidation()
18728: * @param string $errorBag
18729: * @param array $rules
18730: * @param mixed $params
18731: * @static
18732: */
18733: public static function validateWithBag($errorBag, $rules, ...$params)
18734: {
18735: return \Illuminate\Http\Request::validateWithBag($errorBag, $rules, ...$params);
18736: }
18737: /**
18738: *
18739: *
18740: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18741: * @param mixed $absolute
18742: * @static
18743: */
18744: public static function hasValidSignature($absolute = true)
18745: {
18746: return \Illuminate\Http\Request::hasValidSignature($absolute);
18747: }
18748: /**
18749: *
18750: *
18751: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18752: * @static
18753: */
18754: public static function hasValidRelativeSignature()
18755: {
18756: return \Illuminate\Http\Request::hasValidRelativeSignature();
18757: }
18758: /**
18759: *
18760: *
18761: * @see \Illuminate\Foundation\Providers\FoundationServiceProvider::registerRequestSignatureValidation()
18762: * @param mixed $ignoreQuery
18763: * @param mixed $absolute
18764: * @static
18765: */
18766: public static function hasValidSignatureWhileIgnoring($ignoreQuery = [], $absolute = true)
18767: {
18768: return \Illuminate\Http\Request::hasValidSignatureWhileIgnoring($ignoreQuery, $absolute);
18769: }
18770:
18771: }
18772: /**
18773: *
18774: *
18775: */
18776: class RedirectResponse {
18777: /**
18778: *
18779: *
18780: * @see \Laravel\Jetstream\JetstreamServiceProvider::boot()
18781: * @param mixed $message
18782: * @static
18783: */
18784: public static function banner($message)
18785: {
18786: return \Illuminate\Http\RedirectResponse::banner($message);
18787: }
18788: /**
18789: *
18790: *
18791: * @see \Laravel\Jetstream\JetstreamServiceProvider::boot()
18792: * @param mixed $message
18793: * @static
18794: */
18795: public static function dangerBanner($message)
18796: {
18797: return \Illuminate\Http\RedirectResponse::dangerBanner($message);
18798: }
18799:
18800: }
18801:
18802: }
18803:
18804: namespace Livewire\Testing {
18805: /**
18806: *
18807: *
18808: * @mixin \Illuminate\Testing\TestResponse
18809: */
18810: class TestableLivewire {
18811: /**
18812: *
18813: *
18814: * @see \Filament\Support\Testing\TestsActions::parseActionName()
18815: * @param string $name
18816: * @return string
18817: * @static
18818: */
18819: public static function parseActionName($name)
18820: {
18821: return \Livewire\Testing\TestableLivewire::parseActionName($name);
18822: }
18823: /**
18824: *
18825: *
18826: * @see \Filament\Testing\TestsPages::fillForm()
18827: * @param array $state
18828: * @return static
18829: * @static
18830: */
18831: public static function fillForm($state = [])
18832: {
18833: return \Livewire\Testing\TestableLivewire::fillForm($state);
18834: }
18835: /**
18836: *
18837: *
18838: * @see \Filament\Testing\TestsPages::assertFormSet()
18839: * @param array $state
18840: * @return static
18841: * @static
18842: */
18843: public static function assertFormSet($state)
18844: {
18845: return \Livewire\Testing\TestableLivewire::assertFormSet($state);
18846: }
18847: /**
18848: *
18849: *
18850: * @see \Filament\Testing\TestsPages::assertHasFormErrors()
18851: * @param array $keys
18852: * @return static
18853: * @static
18854: */
18855: public static function assertHasFormErrors($keys = [])
18856: {
18857: return \Livewire\Testing\TestableLivewire::assertHasFormErrors($keys);
18858: }
18859: /**
18860: *
18861: *
18862: * @see \Filament\Testing\TestsPages::assertHasNoFormErrors()
18863: * @param array $keys
18864: * @return static
18865: * @static
18866: */
18867: public static function assertHasNoFormErrors($keys = [])
18868: {
18869: return \Livewire\Testing\TestableLivewire::assertHasNoFormErrors($keys);
18870: }
18871: /**
18872: *
18873: *
18874: * @see \Filament\Testing\TestsPages::callPageAction()
18875: * @param string $name
18876: * @param array $data
18877: * @param array $arguments
18878: * @return static
18879: * @static
18880: */
18881: public static function callPageAction($name, $data = [], $arguments = [])
18882: {
18883: return \Livewire\Testing\TestableLivewire::callPageAction($name, $data, $arguments);
18884: }
18885: /**
18886: *
18887: *
18888: * @see \Filament\Testing\TestsPages::assertPageActionExists()
18889: * @param string $name
18890: * @return static
18891: * @static
18892: */
18893: public static function assertPageActionExists($name)
18894: {
18895: return \Livewire\Testing\TestableLivewire::assertPageActionExists($name);
18896: }
18897: /**
18898: *
18899: *
18900: * @see \Filament\Testing\TestsPages::assertPageActionHeld()
18901: * @param string $name
18902: * @return static
18903: * @static
18904: */
18905: public static function assertPageActionHeld($name)
18906: {
18907: return \Livewire\Testing\TestableLivewire::assertPageActionHeld($name);
18908: }
18909: /**
18910: *
18911: *
18912: * @see \Filament\Testing\TestsPages::assertHasPageActionErrors()
18913: * @param array $keys
18914: * @return static
18915: * @static
18916: */
18917: public static function assertHasPageActionErrors($keys = [])
18918: {
18919: return \Livewire\Testing\TestableLivewire::assertHasPageActionErrors($keys);
18920: }
18921: /**
18922: *
18923: *
18924: * @see \Filament\Testing\TestsPages::assertHasNoPageActionErrors()
18925: * @param array $keys
18926: * @return static
18927: * @static
18928: */
18929: public static function assertHasNoPageActionErrors($keys = [])
18930: {
18931: return \Livewire\Testing\TestableLivewire::assertHasNoPageActionErrors($keys);
18932: }
18933: /**
18934: *
18935: *
18936: * @see \Filament\Tables\Testing\TestsActions::callTableAction()
18937: * @param string $name
18938: * @param mixed $record
18939: * @param array $data
18940: * @param array $arguments
18941: * @return static
18942: * @static
18943: */
18944: public static function callTableAction($name, $record = null, $data = [], $arguments = [])
18945: {
18946: return \Livewire\Testing\TestableLivewire::callTableAction($name, $record, $data, $arguments);
18947: }
18948: /**
18949: *
18950: *
18951: * @see \Filament\Tables\Testing\TestsActions::assertTableActionExists()
18952: * @param string $name
18953: * @return static
18954: * @static
18955: */
18956: public static function assertTableActionExists($name)
18957: {
18958: return \Livewire\Testing\TestableLivewire::assertTableActionExists($name);
18959: }
18960: /**
18961: *
18962: *
18963: * @see \Filament\Tables\Testing\TestsActions::assertTableActionHeld()
18964: * @param string $name
18965: * @return static
18966: * @static
18967: */
18968: public static function assertTableActionHeld($name)
18969: {
18970: return \Livewire\Testing\TestableLivewire::assertTableActionHeld($name);
18971: }
18972: /**
18973: *
18974: *
18975: * @see \Filament\Tables\Testing\TestsActions::assertHasTableActionErrors()
18976: * @param array $keys
18977: * @return static
18978: * @static
18979: */
18980: public static function assertHasTableActionErrors($keys = [])
18981: {
18982: return \Livewire\Testing\TestableLivewire::assertHasTableActionErrors($keys);
18983: }
18984: /**
18985: *
18986: *
18987: * @see \Filament\Tables\Testing\TestsActions::assertHasNoTableActionErrors()
18988: * @param array $keys
18989: * @return static
18990: * @static
18991: */
18992: public static function assertHasNoTableActionErrors($keys = [])
18993: {
18994: return \Livewire\Testing\TestableLivewire::assertHasNoTableActionErrors($keys);
18995: }
18996: /**
18997: *
18998: *
18999: * @see \Filament\Tables\Testing\TestsActions::callTableBulkAction()
19000: * @param string $name
19001: * @param \Illuminate\Support\Collection|array $records
19002: * @param array $data
19003: * @param array $arguments
19004: * @return static
19005: * @static
19006: */
19007: public static function callTableBulkAction($name, $records, $data = [], $arguments = [])
19008: {
19009: return \Livewire\Testing\TestableLivewire::callTableBulkAction($name, $records, $data, $arguments);
19010: }
19011: /**
19012: *
19013: *
19014: * @see \Filament\Tables\Testing\TestsActions::assertTableBulkActionExists()
19015: * @param string $name
19016: * @return static
19017: * @static
19018: */
19019: public static function assertTableBulkActionExists($name)
19020: {
19021: return \Livewire\Testing\TestableLivewire::assertTableBulkActionExists($name);
19022: }
19023: /**
19024: *
19025: *
19026: * @see \Filament\Tables\Testing\TestsActions::assertTableBulkActionHeld()
19027: * @param string $name
19028: * @return static
19029: * @static
19030: */
19031: public static function assertTableBulkActionHeld($name)
19032: {
19033: return \Livewire\Testing\TestableLivewire::assertTableBulkActionHeld($name);
19034: }
19035: /**
19036: *
19037: *
19038: * @see \Filament\Tables\Testing\TestsActions::assertHasTableBulkActionErrors()
19039: * @param array $keys
19040: * @return static
19041: * @static
19042: */
19043: public static function assertHasTableBulkActionErrors($keys = [])
19044: {
19045: return \Livewire\Testing\TestableLivewire::assertHasTableBulkActionErrors($keys);
19046: }
19047: /**
19048: *
19049: *
19050: * @see \Filament\Tables\Testing\TestsActions::assertHasNoTableBulkActionErrors()
19051: * @param array $keys
19052: * @return static
19053: * @static
19054: */
19055: public static function assertHasNoTableBulkActionErrors($keys = [])
19056: {
19057: return \Livewire\Testing\TestableLivewire::assertHasNoTableBulkActionErrors($keys);
19058: }
19059: /**
19060: *
19061: *
19062: * @see \Filament\Tables\Testing\TestsColumns::assertCanRenderTableColumn()
19063: * @param string $name
19064: * @return static
19065: * @static
19066: */
19067: public static function assertCanRenderTableColumn($name)
19068: {
19069: return \Livewire\Testing\TestableLivewire::assertCanRenderTableColumn($name);
19070: }
19071: /**
19072: *
19073: *
19074: * @see \Filament\Tables\Testing\TestsColumns::assertTableColumnExists()
19075: * @param string $name
19076: * @return static
19077: * @static
19078: */
19079: public static function assertTableColumnExists($name)
19080: {
19081: return \Livewire\Testing\TestableLivewire::assertTableColumnExists($name);
19082: }
19083: /**
19084: *
19085: *
19086: * @see \Filament\Tables\Testing\TestsColumns::sortTable()
19087: * @param string|null $name
19088: * @param string|null $direction
19089: * @return static
19090: * @static
19091: */
19092: public static function sortTable($name = null, $direction = null)
19093: {
19094: return \Livewire\Testing\TestableLivewire::sortTable($name, $direction);
19095: }
19096: /**
19097: *
19098: *
19099: * @see \Filament\Tables\Testing\TestsColumns::searchTable()
19100: * @param string|null $search
19101: * @return static
19102: * @static
19103: */
19104: public static function searchTable($search = null)
19105: {
19106: return \Livewire\Testing\TestableLivewire::searchTable($search);
19107: }
19108: /**
19109: *
19110: *
19111: * @see \Filament\Tables\Testing\TestsFilters::filterTable()
19112: * @param string $name
19113: * @param mixed $data
19114: * @return static
19115: * @static
19116: */
19117: public static function filterTable($name, $data = null)
19118: {
19119: return \Livewire\Testing\TestableLivewire::filterTable($name, $data);
19120: }
19121: /**
19122: *
19123: *
19124: * @see \Filament\Tables\Testing\TestsFilters::resetTableFilters()
19125: * @return static
19126: * @static
19127: */
19128: public static function resetTableFilters()
19129: {
19130: return \Livewire\Testing\TestableLivewire::resetTableFilters();
19131: }
19132: /**
19133: *
19134: *
19135: * @see \Filament\Tables\Testing\TestsFilters::assertTableFilterExists()
19136: * @param string $name
19137: * @return static
19138: * @static
19139: */
19140: public static function assertTableFilterExists($name)
19141: {
19142: return \Livewire\Testing\TestableLivewire::assertTableFilterExists($name);
19143: }
19144: /**
19145: *
19146: *
19147: * @see \Filament\Tables\Testing\TestsFilters::parseFilterName()
19148: * @param string $name
19149: * @return string
19150: * @static
19151: */
19152: public static function parseFilterName($name)
19153: {
19154: return \Livewire\Testing\TestableLivewire::parseFilterName($name);
19155: }
19156: /**
19157: *
19158: *
19159: * @see \Filament\Tables\Testing\TestsRecords::assertCanSeeTableRecords()
19160: * @param \Illuminate\Support\Collection|array $records
19161: * @param bool $inOrder
19162: * @return static
19163: * @static
19164: */
19165: public static function assertCanSeeTableRecords($records, $inOrder = false)
19166: {
19167: return \Livewire\Testing\TestableLivewire::assertCanSeeTableRecords($records, $inOrder);
19168: }
19169: /**
19170: *
19171: *
19172: * @see \Filament\Tables\Testing\TestsRecords::assertCanNotSeeTableRecords()
19173: * @param \Illuminate\Support\Collection|array $records
19174: * @return static
19175: * @static
19176: */
19177: public static function assertCanNotSeeTableRecords($records)
19178: {
19179: return \Livewire\Testing\TestableLivewire::assertCanNotSeeTableRecords($records);
19180: }
19181: /**
19182: *
19183: *
19184: * @see \Filament\Tables\Testing\TestsRecords::assertCountTableRecords()
19185: * @param int $count
19186: * @return static
19187: * @static
19188: */
19189: public static function assertCountTableRecords($count)
19190: {
19191: return \Livewire\Testing\TestableLivewire::assertCountTableRecords($count);
19192: }
19193:
19194: }
19195:
19196: }
19197:
19198: namespace Illuminate\Testing {
19199: /**
19200: *
19201: *
19202: * @mixin \Illuminate\Http\Response
19203: */
19204: class TestResponse {
19205: /**
19206: *
19207: *
19208: * @see \Livewire\LivewireServiceProvider::registerTestMacros()
19209: * @param mixed $component
19210: * @static
19211: */
19212: public static function assertSeeLivewire($component)
19213: {
19214: return \Illuminate\Testing\TestResponse::assertSeeLivewire($component);
19215: }
19216: /**
19217: *
19218: *
19219: * @see \Livewire\LivewireServiceProvider::registerTestMacros()
19220: * @param mixed $component
19221: * @static
19222: */
19223: public static function assertDontSeeLivewire($component)
19224: {
19225: return \Illuminate\Testing\TestResponse::assertDontSeeLivewire($component);
19226: }
19227: /**
19228: *
19229: *
19230: * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros()
19231: * @static
19232: */
19233: public static function ray()
19234: {
19235: return \Illuminate\Testing\TestResponse::ray();
19236: }
19237:
19238: }
19239: /**
19240: *
19241: *
19242: */
19243: class TestView {
19244: /**
19245: *
19246: *
19247: * @see \Livewire\LivewireServiceProvider::registerTestMacros()
19248: * @param mixed $component
19249: * @static
19250: */
19251: public static function assertSeeLivewire($component)
19252: {
19253: return \Illuminate\Testing\TestView::assertSeeLivewire($component);
19254: }
19255: /**
19256: *
19257: *
19258: * @see \Livewire\LivewireServiceProvider::registerTestMacros()
19259: * @param mixed $component
19260: * @static
19261: */
19262: public static function assertDontSeeLivewire($component)
19263: {
19264: return \Illuminate\Testing\TestView::assertDontSeeLivewire($component);
19265: }
19266:
19267: }
19268:
19269: }
19270:
19271: namespace Illuminate\Database\Query {
19272: /**
19273: *
19274: *
19275: */
19276: class Builder {
19277: /**
19278: *
19279: *
19280: * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros()
19281: * @static
19282: */
19283: public static function ray()
19284: {
19285: return \Illuminate\Database\Query\Builder::ray();
19286: }
19287:
19288: }
19289:
19290: }
19291:
19292: namespace Illuminate\Http\Client {
19293: /**
19294: *
19295: *
19296: */
19297: class PendingRequest {
19298: /**
19299: *
19300: *
19301: * @see \Bilfeldt\LaravelHttpClientLogger\LaravelHttpClientLoggerServiceProvider::packageBooted()
19302: * @param mixed $context
19303: * @param mixed $config
19304: * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggerInterface|null $logger
19305: * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggingFilterInterface|null $filter
19306: * @static
19307: */
19308: public static function log($context = [], $config = [], $logger = null, $filter = null)
19309: {
19310: return \Illuminate\Http\Client\PendingRequest::log($context, $config, $logger, $filter);
19311: }
19312: /**
19313: *
19314: *
19315: * @see \Bilfeldt\LaravelHttpClientLogger\LaravelHttpClientLoggerServiceProvider::packageBooted()
19316: * @param mixed $condition
19317: * @param mixed $context
19318: * @param mixed $config
19319: * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggerInterface|null $logger
19320: * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggingFilterInterface|null $filter
19321: * @static
19322: */
19323: public static function logWhen($condition, $context = [], $config = [], $logger = null, $filter = null)
19324: {
19325: return \Illuminate\Http\Client\PendingRequest::logWhen($condition, $context, $config, $logger, $filter);
19326: }
19327: /**
19328: *
19329: *
19330: * @see \Bilfeldt\LaravelHttpClientLogger\LaravelHttpClientLoggerServiceProvider::packageBooted()
19331: * @param \Bilfeldt\LaravelHttpClientLogger\HttpLoggerInterface|null $logger
19332: * @static
19333: */
19334: public static function logWith($logger = null)
19335: {
19336: return \Illuminate\Http\Client\PendingRequest::logWith($logger);
19337: }
19338:
19339: }
19340:
19341: }
19342:
19343: namespace Illuminate\View {
19344: /**
19345: *
19346: *
19347: */
19348: class ComponentAttributeBag {
19349: /**
19350: *
19351: *
19352: * @see \Livewire\LivewireServiceProvider::registerViewMacros()
19353: * @param mixed $name
19354: * @static
19355: */
19356: public static function wire($name)
19357: {
19358: return \Illuminate\View\ComponentAttributeBag::wire($name);
19359: }
19360:
19361: }
19362: /**
19363: *
19364: *
19365: */
19366: class View {
19367: /**
19368: *
19369: *
19370: * @see \Livewire\Macros\ViewMacros::extends()
19371: * @param mixed $view
19372: * @param mixed $params
19373: * @static
19374: */
19375: public static function extends($view, $params = [])
19376: {
19377: return \Illuminate\View\View::extends($view, $params);
19378: }
19379: /**
19380: *
19381: *
19382: * @see \Livewire\Macros\ViewMacros::layout()
19383: * @param mixed $view
19384: * @param mixed $params
19385: * @static
19386: */
19387: public static function layout($view, $params = [])
19388: {
19389: return \Illuminate\View\View::layout($view, $params);
19390: }
19391: /**
19392: *
19393: *
19394: * @see \Livewire\Macros\ViewMacros::layoutData()
19395: * @param mixed $data
19396: * @static
19397: */
19398: public static function layoutData($data = [])
19399: {
19400: return \Illuminate\View\View::layoutData($data);
19401: }
19402: /**
19403: *
19404: *
19405: * @see \Livewire\Macros\ViewMacros::section()
19406: * @param mixed $section
19407: * @static
19408: */
19409: public static function section($section)
19410: {
19411: return \Illuminate\View\View::section($section);
19412: }
19413: /**
19414: *
19415: *
19416: * @see \Livewire\Macros\ViewMacros::slot()
19417: * @param mixed $slot
19418: * @static
19419: */
19420: public static function slot($slot)
19421: {
19422: return \Illuminate\View\View::slot($slot);
19423: }
19424:
19425: }
19426:
19427: }
19428:
19429:
19430: namespace {
19431: class App extends \Illuminate\Support\Facades\App {}
19432: class Arr extends \Illuminate\Support\Arr {}
19433: class Artisan extends \Illuminate\Support\Facades\Artisan {}
19434: class Auth extends \Illuminate\Support\Facades\Auth {}
19435: class Blade extends \Illuminate\Support\Facades\Blade {}
19436: class Broadcast extends \Illuminate\Support\Facades\Broadcast {}
19437: class Bus extends \Illuminate\Support\Facades\Bus {}
19438: class Cache extends \Illuminate\Support\Facades\Cache {}
19439: class Config extends \Illuminate\Support\Facades\Config {}
19440: class Cookie extends \Illuminate\Support\Facades\Cookie {}
19441: class Crypt extends \Illuminate\Support\Facades\Crypt {}
19442: class Date extends \Illuminate\Support\Facades\Date {}
19443: class DB extends \Illuminate\Support\Facades\DB {}
19444: class Eloquent extends \Illuminate\Database\Eloquent\Model {
19445: /**
19446: * Create and return an un-saved model instance.
19447: *
19448: * @param array $attributes
19449: * @return \Illuminate\Database\Eloquent\Model|static
19450: * @static
19451: */
19452: public static function make($attributes = [])
19453: {
19454: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19455: return $instance->make($attributes);
19456: }
19457:
19458: /**
19459: * Register a new global scope.
19460: *
19461: * @param string $identifier
19462: * @param \Illuminate\Database\Eloquent\Scope|\Closure $scope
19463: * @return \Illuminate\Database\Eloquent\Builder|static
19464: * @static
19465: */
19466: public static function withGlobalScope($identifier, $scope)
19467: {
19468: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19469: return $instance->withGlobalScope($identifier, $scope);
19470: }
19471:
19472: /**
19473: * Remove a registered global scope.
19474: *
19475: * @param \Illuminate\Database\Eloquent\Scope|string $scope
19476: * @return \Illuminate\Database\Eloquent\Builder|static
19477: * @static
19478: */
19479: public static function withoutGlobalScope($scope)
19480: {
19481: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19482: return $instance->withoutGlobalScope($scope);
19483: }
19484:
19485: /**
19486: * Remove all or passed registered global scopes.
19487: *
19488: * @param array|null $scopes
19489: * @return \Illuminate\Database\Eloquent\Builder|static
19490: * @static
19491: */
19492: public static function withoutGlobalScopes($scopes = null)
19493: {
19494: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19495: return $instance->withoutGlobalScopes($scopes);
19496: }
19497:
19498: /**
19499: * Get an array of global scopes that were removed from the query.
19500: *
19501: * @return array
19502: * @static
19503: */
19504: public static function removedScopes()
19505: {
19506: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19507: return $instance->removedScopes();
19508: }
19509:
19510: /**
19511: * Add a where clause on the primary key to the query.
19512: *
19513: * @param mixed $id
19514: * @return \Illuminate\Database\Eloquent\Builder|static
19515: * @static
19516: */
19517: public static function whereKey($id)
19518: {
19519: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19520: return $instance->whereKey($id);
19521: }
19522:
19523: /**
19524: * Add a where clause on the primary key to the query.
19525: *
19526: * @param mixed $id
19527: * @return \Illuminate\Database\Eloquent\Builder|static
19528: * @static
19529: */
19530: public static function whereKeyNot($id)
19531: {
19532: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19533: return $instance->whereKeyNot($id);
19534: }
19535:
19536: /**
19537: * Add a basic where clause to the query.
19538: *
19539: * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19540: * @param mixed $operator
19541: * @param mixed $value
19542: * @param string $boolean
19543: * @return \Illuminate\Database\Eloquent\Builder|static
19544: * @static
19545: */
19546: public static function where($column, $operator = null, $value = null, $boolean = 'and')
19547: {
19548: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19549: return $instance->where($column, $operator, $value, $boolean);
19550: }
19551:
19552: /**
19553: * Add a basic where clause to the query, and return the first result.
19554: *
19555: * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19556: * @param mixed $operator
19557: * @param mixed $value
19558: * @param string $boolean
19559: * @return \Illuminate\Database\Eloquent\Model|static|null
19560: * @static
19561: */
19562: public static function firstWhere($column, $operator = null, $value = null, $boolean = 'and')
19563: {
19564: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19565: return $instance->firstWhere($column, $operator, $value, $boolean);
19566: }
19567:
19568: /**
19569: * Add an "or where" clause to the query.
19570: *
19571: * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column
19572: * @param mixed $operator
19573: * @param mixed $value
19574: * @return \Illuminate\Database\Eloquent\Builder|static
19575: * @static
19576: */
19577: public static function orWhere($column, $operator = null, $value = null)
19578: {
19579: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19580: return $instance->orWhere($column, $operator, $value);
19581: }
19582:
19583: /**
19584: * Add a basic "where not" clause to the query.
19585: *
19586: * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
19587: * @param mixed $operator
19588: * @param mixed $value
19589: * @param string $boolean
19590: * @return \Illuminate\Database\Eloquent\Builder|static
19591: * @static
19592: */
19593: public static function whereNot($column, $operator = null, $value = null, $boolean = 'and')
19594: {
19595: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19596: return $instance->whereNot($column, $operator, $value, $boolean);
19597: }
19598:
19599: /**
19600: * Add an "or where not" clause to the query.
19601: *
19602: * @param \Closure|array|string|\Illuminate\Database\Query\Expression $column
19603: * @param mixed $operator
19604: * @param mixed $value
19605: * @return \Illuminate\Database\Eloquent\Builder|static
19606: * @static
19607: */
19608: public static function orWhereNot($column, $operator = null, $value = null)
19609: {
19610: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19611: return $instance->orWhereNot($column, $operator, $value);
19612: }
19613:
19614: /**
19615: * Add an "order by" clause for a timestamp to the query.
19616: *
19617: * @param string|\Illuminate\Database\Query\Expression $column
19618: * @return \Illuminate\Database\Eloquent\Builder|static
19619: * @static
19620: */
19621: public static function latest($column = null)
19622: {
19623: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19624: return $instance->latest($column);
19625: }
19626:
19627: /**
19628: * Add an "order by" clause for a timestamp to the query.
19629: *
19630: * @param string|\Illuminate\Database\Query\Expression $column
19631: * @return \Illuminate\Database\Eloquent\Builder|static
19632: * @static
19633: */
19634: public static function oldest($column = null)
19635: {
19636: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19637: return $instance->oldest($column);
19638: }
19639:
19640: /**
19641: * Create a collection of models from plain arrays.
19642: *
19643: * @param array $items
19644: * @return \Illuminate\Database\Eloquent\Collection
19645: * @static
19646: */
19647: public static function hydrate($items)
19648: {
19649: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19650: return $instance->hydrate($items);
19651: }
19652:
19653: /**
19654: * Create a collection of models from a raw query.
19655: *
19656: * @param string $query
19657: * @param array $bindings
19658: * @return \Illuminate\Database\Eloquent\Collection
19659: * @static
19660: */
19661: public static function fromQuery($query, $bindings = [])
19662: {
19663: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19664: return $instance->fromQuery($query, $bindings);
19665: }
19666:
19667: /**
19668: * Find a model by its primary key.
19669: *
19670: * @param mixed $id
19671: * @param array|string $columns
19672: * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|null
19673: * @static
19674: */
19675: public static function find($id, $columns = [])
19676: {
19677: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19678: return $instance->find($id, $columns);
19679: }
19680:
19681: /**
19682: * Find multiple models by their primary keys.
19683: *
19684: * @param \Illuminate\Contracts\Support\Arrayable|array $ids
19685: * @param array|string $columns
19686: * @return \Illuminate\Database\Eloquent\Collection
19687: * @static
19688: */
19689: public static function findMany($ids, $columns = [])
19690: {
19691: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19692: return $instance->findMany($ids, $columns);
19693: }
19694:
19695: /**
19696: * Find a model by its primary key or throw an exception.
19697: *
19698: * @param mixed $id
19699: * @param array|string $columns
19700: * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static|static[]
19701: * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19702: * @static
19703: */
19704: public static function findOrFail($id, $columns = [])
19705: {
19706: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19707: return $instance->findOrFail($id, $columns);
19708: }
19709:
19710: /**
19711: * Find a model by its primary key or return fresh model instance.
19712: *
19713: * @param mixed $id
19714: * @param array|string $columns
19715: * @return \Illuminate\Database\Eloquent\Model|static
19716: * @static
19717: */
19718: public static function findOrNew($id, $columns = [])
19719: {
19720: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19721: return $instance->findOrNew($id, $columns);
19722: }
19723:
19724: /**
19725: * Find a model by its primary key or call a callback.
19726: *
19727: * @param mixed $id
19728: * @param \Closure|array|string $columns
19729: * @param \Closure|null $callback
19730: * @return \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection|static[]|static|mixed
19731: * @static
19732: */
19733: public static function findOr($id, $columns = [], $callback = null)
19734: {
19735: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19736: return $instance->findOr($id, $columns, $callback);
19737: }
19738:
19739: /**
19740: * Get the first record matching the attributes or instantiate it.
19741: *
19742: * @param array $attributes
19743: * @param array $values
19744: * @return \Illuminate\Database\Eloquent\Model|static
19745: * @static
19746: */
19747: public static function firstOrNew($attributes = [], $values = [])
19748: {
19749: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19750: return $instance->firstOrNew($attributes, $values);
19751: }
19752:
19753: /**
19754: * Get the first record matching the attributes or create it.
19755: *
19756: * @param array $attributes
19757: * @param array $values
19758: * @return \Illuminate\Database\Eloquent\Model|static
19759: * @static
19760: */
19761: public static function firstOrCreate($attributes = [], $values = [])
19762: {
19763: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19764: return $instance->firstOrCreate($attributes, $values);
19765: }
19766:
19767: /**
19768: * Create or update a record matching the attributes, and fill it with values.
19769: *
19770: * @param array $attributes
19771: * @param array $values
19772: * @return \Illuminate\Database\Eloquent\Model|static
19773: * @static
19774: */
19775: public static function updateOrCreate($attributes, $values = [])
19776: {
19777: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19778: return $instance->updateOrCreate($attributes, $values);
19779: }
19780:
19781: /**
19782: * Execute the query and get the first result or throw an exception.
19783: *
19784: * @param array|string $columns
19785: * @return \Illuminate\Database\Eloquent\Model|static
19786: * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19787: * @static
19788: */
19789: public static function firstOrFail($columns = [])
19790: {
19791: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19792: return $instance->firstOrFail($columns);
19793: }
19794:
19795: /**
19796: * Execute the query and get the first result or call a callback.
19797: *
19798: * @param \Closure|array|string $columns
19799: * @param \Closure|null $callback
19800: * @return \Illuminate\Database\Eloquent\Model|static|mixed
19801: * @static
19802: */
19803: public static function firstOr($columns = [], $callback = null)
19804: {
19805: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19806: return $instance->firstOr($columns, $callback);
19807: }
19808:
19809: /**
19810: * Execute the query and get the first result if it's the sole matching record.
19811: *
19812: * @param array|string $columns
19813: * @return \Illuminate\Database\Eloquent\Model
19814: * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19815: * @throws \Illuminate\Database\MultipleRecordsFoundException
19816: * @static
19817: */
19818: public static function sole($columns = [])
19819: {
19820: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19821: return $instance->sole($columns);
19822: }
19823:
19824: /**
19825: * Get a single column's value from the first result of a query.
19826: *
19827: * @param string|\Illuminate\Database\Query\Expression $column
19828: * @return mixed
19829: * @static
19830: */
19831: public static function value($column)
19832: {
19833: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19834: return $instance->value($column);
19835: }
19836:
19837: /**
19838: * Get a single column's value from the first result of a query if it's the sole matching record.
19839: *
19840: * @param string|\Illuminate\Database\Query\Expression $column
19841: * @return mixed
19842: * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19843: * @throws \Illuminate\Database\MultipleRecordsFoundException
19844: * @static
19845: */
19846: public static function soleValue($column)
19847: {
19848: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19849: return $instance->soleValue($column);
19850: }
19851:
19852: /**
19853: * Get a single column's value from the first result of the query or throw an exception.
19854: *
19855: * @param string|\Illuminate\Database\Query\Expression $column
19856: * @return mixed
19857: * @throws \Illuminate\Database\Eloquent\ModelNotFoundException<\Illuminate\Database\Eloquent\Model>
19858: * @static
19859: */
19860: public static function valueOrFail($column)
19861: {
19862: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19863: return $instance->valueOrFail($column);
19864: }
19865:
19866: /**
19867: * Execute the query as a "select" statement.
19868: *
19869: * @param array|string $columns
19870: * @return \Illuminate\Database\Eloquent\Collection|static[]
19871: * @static
19872: */
19873: public static function get($columns = [])
19874: {
19875: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19876: return $instance->get($columns);
19877: }
19878:
19879: /**
19880: * Get the hydrated models without eager loading.
19881: *
19882: * @param array|string $columns
19883: * @return \Illuminate\Database\Eloquent\Model[]|static[]
19884: * @static
19885: */
19886: public static function getModels($columns = [])
19887: {
19888: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19889: return $instance->getModels($columns);
19890: }
19891:
19892: /**
19893: * Eager load the relationships for the models.
19894: *
19895: * @param array $models
19896: * @return array
19897: * @static
19898: */
19899: public static function eagerLoadRelations($models)
19900: {
19901: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19902: return $instance->eagerLoadRelations($models);
19903: }
19904:
19905: /**
19906: * Get a lazy collection for the given query.
19907: *
19908: * @return \Illuminate\Support\LazyCollection
19909: * @static
19910: */
19911: public static function cursor()
19912: {
19913: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19914: return $instance->cursor();
19915: }
19916:
19917: /**
19918: * Get an array with the values of a given column.
19919: *
19920: * @param string|\Illuminate\Database\Query\Expression $column
19921: * @param string|null $key
19922: * @return \Illuminate\Support\Collection
19923: * @static
19924: */
19925: public static function pluck($column, $key = null)
19926: {
19927: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19928: return $instance->pluck($column, $key);
19929: }
19930:
19931: /**
19932: * Paginate the given query.
19933: *
19934: * @param int|null|\Closure $perPage
19935: * @param array|string $columns
19936: * @param string $pageName
19937: * @param int|null $page
19938: * @return \Illuminate\Contracts\Pagination\LengthAwarePaginator
19939: * @throws \InvalidArgumentException
19940: * @static
19941: */
19942: public static function paginate($perPage = null, $columns = [], $pageName = 'page', $page = null)
19943: {
19944: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19945: return $instance->paginate($perPage, $columns, $pageName, $page);
19946: }
19947:
19948: /**
19949: * Paginate the given query into a simple paginator.
19950: *
19951: * @param int|null $perPage
19952: * @param array|string $columns
19953: * @param string $pageName
19954: * @param int|null $page
19955: * @return \Illuminate\Contracts\Pagination\Paginator
19956: * @static
19957: */
19958: public static function simplePaginate($perPage = null, $columns = [], $pageName = 'page', $page = null)
19959: {
19960: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19961: return $instance->simplePaginate($perPage, $columns, $pageName, $page);
19962: }
19963:
19964: /**
19965: * Paginate the given query into a cursor paginator.
19966: *
19967: * @param int|null $perPage
19968: * @param array|string $columns
19969: * @param string $cursorName
19970: * @param \Illuminate\Pagination\Cursor|string|null $cursor
19971: * @return \Illuminate\Contracts\Pagination\CursorPaginator
19972: * @static
19973: */
19974: public static function cursorPaginate($perPage = null, $columns = [], $cursorName = 'cursor', $cursor = null)
19975: {
19976: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19977: return $instance->cursorPaginate($perPage, $columns, $cursorName, $cursor);
19978: }
19979:
19980: /**
19981: * Save a new model and return the instance.
19982: *
19983: * @param array $attributes
19984: * @return \Illuminate\Database\Eloquent\Model|$this
19985: * @static
19986: */
19987: public static function create($attributes = [])
19988: {
19989: /** @var \Illuminate\Database\Eloquent\Builder $instance */
19990: return $instance->create($attributes);
19991: }
19992:
19993: /**
19994: * Save a new model and return the instance. Allow mass-assignment.
19995: *
19996: * @param array $attributes
19997: * @return \Illuminate\Database\Eloquent\Model|$this
19998: * @static
19999: */
20000: public static function forceCreate($attributes)
20001: {
20002: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20003: return $instance->forceCreate($attributes);
20004: }
20005:
20006: /**
20007: * Insert new records or update the existing ones.
20008: *
20009: * @param array $values
20010: * @param array|string $uniqueBy
20011: * @param array|null $update
20012: * @return int
20013: * @static
20014: */
20015: public static function upsert($values, $uniqueBy, $update = null)
20016: {
20017: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20018: return $instance->upsert($values, $uniqueBy, $update);
20019: }
20020:
20021: /**
20022: * Register a replacement for the default delete function.
20023: *
20024: * @param \Closure $callback
20025: * @return void
20026: * @static
20027: */
20028: public static function onDelete($callback)
20029: {
20030: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20031: $instance->onDelete($callback);
20032: }
20033:
20034: /**
20035: * Call the given local model scopes.
20036: *
20037: * @param array|string $scopes
20038: * @return static|mixed
20039: * @static
20040: */
20041: public static function scopes($scopes)
20042: {
20043: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20044: return $instance->scopes($scopes);
20045: }
20046:
20047: /**
20048: * Apply the scopes to the Eloquent builder instance and return it.
20049: *
20050: * @return static
20051: * @static
20052: */
20053: public static function applyScopes()
20054: {
20055: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20056: return $instance->applyScopes();
20057: }
20058:
20059: /**
20060: * Prevent the specified relations from being eager loaded.
20061: *
20062: * @param mixed $relations
20063: * @return \Illuminate\Database\Eloquent\Builder|static
20064: * @static
20065: */
20066: public static function without($relations)
20067: {
20068: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20069: return $instance->without($relations);
20070: }
20071:
20072: /**
20073: * Set the relationships that should be eager loaded while removing any previously added eager loading specifications.
20074: *
20075: * @param mixed $relations
20076: * @return \Illuminate\Database\Eloquent\Builder|static
20077: * @static
20078: */
20079: public static function withOnly($relations)
20080: {
20081: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20082: return $instance->withOnly($relations);
20083: }
20084:
20085: /**
20086: * Create a new instance of the model being queried.
20087: *
20088: * @param array $attributes
20089: * @return \Illuminate\Database\Eloquent\Model|static
20090: * @static
20091: */
20092: public static function newModelInstance($attributes = [])
20093: {
20094: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20095: return $instance->newModelInstance($attributes);
20096: }
20097:
20098: /**
20099: * Apply query-time casts to the model instance.
20100: *
20101: * @param array $casts
20102: * @return \Illuminate\Database\Eloquent\Builder|static
20103: * @static
20104: */
20105: public static function withCasts($casts)
20106: {
20107: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20108: return $instance->withCasts($casts);
20109: }
20110:
20111: /**
20112: * Get the underlying query builder instance.
20113: *
20114: * @return \Illuminate\Database\Query\Builder
20115: * @static
20116: */
20117: public static function getQuery()
20118: {
20119: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20120: return $instance->getQuery();
20121: }
20122:
20123: /**
20124: * Set the underlying query builder instance.
20125: *
20126: * @param \Illuminate\Database\Query\Builder $query
20127: * @return \Illuminate\Database\Eloquent\Builder|static
20128: * @static
20129: */
20130: public static function setQuery($query)
20131: {
20132: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20133: return $instance->setQuery($query);
20134: }
20135:
20136: /**
20137: * Get a base query builder instance.
20138: *
20139: * @return \Illuminate\Database\Query\Builder
20140: * @static
20141: */
20142: public static function toBase()
20143: {
20144: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20145: return $instance->toBase();
20146: }
20147:
20148: /**
20149: * Get the relationships being eagerly loaded.
20150: *
20151: * @return array
20152: * @static
20153: */
20154: public static function getEagerLoads()
20155: {
20156: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20157: return $instance->getEagerLoads();
20158: }
20159:
20160: /**
20161: * Set the relationships being eagerly loaded.
20162: *
20163: * @param array $eagerLoad
20164: * @return \Illuminate\Database\Eloquent\Builder|static
20165: * @static
20166: */
20167: public static function setEagerLoads($eagerLoad)
20168: {
20169: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20170: return $instance->setEagerLoads($eagerLoad);
20171: }
20172:
20173: /**
20174: * Indicate that the given relationships should not be eagerly loaded.
20175: *
20176: * @param array $relations
20177: * @return \Illuminate\Database\Eloquent\Builder|static
20178: * @static
20179: */
20180: public static function withoutEagerLoad($relations)
20181: {
20182: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20183: return $instance->withoutEagerLoad($relations);
20184: }
20185:
20186: /**
20187: * Flush the relationships being eagerly loaded.
20188: *
20189: * @return \Illuminate\Database\Eloquent\Builder|static
20190: * @static
20191: */
20192: public static function withoutEagerLoads()
20193: {
20194: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20195: return $instance->withoutEagerLoads();
20196: }
20197:
20198: /**
20199: * Get the model instance being queried.
20200: *
20201: * @return \Illuminate\Database\Eloquent\Model|static
20202: * @static
20203: */
20204: public static function getModel()
20205: {
20206: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20207: return $instance->getModel();
20208: }
20209:
20210: /**
20211: * Set a model instance for the model being queried.
20212: *
20213: * @param \Illuminate\Database\Eloquent\Model $model
20214: * @return \Illuminate\Database\Eloquent\Builder|static
20215: * @static
20216: */
20217: public static function setModel($model)
20218: {
20219: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20220: return $instance->setModel($model);
20221: }
20222:
20223: /**
20224: * Get the given macro by name.
20225: *
20226: * @param string $name
20227: * @return \Closure
20228: * @static
20229: */
20230: public static function getMacro($name)
20231: {
20232: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20233: return $instance->getMacro($name);
20234: }
20235:
20236: /**
20237: * Checks if a macro is registered.
20238: *
20239: * @param string $name
20240: * @return bool
20241: * @static
20242: */
20243: public static function hasMacro($name)
20244: {
20245: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20246: return $instance->hasMacro($name);
20247: }
20248:
20249: /**
20250: * Get the given global macro by name.
20251: *
20252: * @param string $name
20253: * @return \Closure
20254: * @static
20255: */
20256: public static function getGlobalMacro($name)
20257: {
20258: return \Illuminate\Database\Eloquent\Builder::getGlobalMacro($name);
20259: }
20260:
20261: /**
20262: * Checks if a global macro is registered.
20263: *
20264: * @param string $name
20265: * @return bool
20266: * @static
20267: */
20268: public static function hasGlobalMacro($name)
20269: {
20270: return \Illuminate\Database\Eloquent\Builder::hasGlobalMacro($name);
20271: }
20272:
20273: /**
20274: * Clone the Eloquent query builder.
20275: *
20276: * @return static
20277: * @static
20278: */
20279: public static function clone()
20280: {
20281: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20282: return $instance->clone();
20283: }
20284:
20285: /**
20286: * Chunk the results of the query.
20287: *
20288: * @param int $count
20289: * @param callable $callback
20290: * @return bool
20291: * @static
20292: */
20293: public static function chunk($count, $callback)
20294: {
20295: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20296: return $instance->chunk($count, $callback);
20297: }
20298:
20299: /**
20300: * Run a map over each item while chunking.
20301: *
20302: * @param callable $callback
20303: * @param int $count
20304: * @return \Illuminate\Support\Collection
20305: * @static
20306: */
20307: public static function chunkMap($callback, $count = 1000)
20308: {
20309: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20310: return $instance->chunkMap($callback, $count);
20311: }
20312:
20313: /**
20314: * Execute a callback over each item while chunking.
20315: *
20316: * @param callable $callback
20317: * @param int $count
20318: * @return bool
20319: * @throws \RuntimeException
20320: * @static
20321: */
20322: public static function each($callback, $count = 1000)
20323: {
20324: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20325: return $instance->each($callback, $count);
20326: }
20327:
20328: /**
20329: * Chunk the results of a query by comparing IDs.
20330: *
20331: * @param int $count
20332: * @param callable $callback
20333: * @param string|null $column
20334: * @param string|null $alias
20335: * @return bool
20336: * @static
20337: */
20338: public static function chunkById($count, $callback, $column = null, $alias = null)
20339: {
20340: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20341: return $instance->chunkById($count, $callback, $column, $alias);
20342: }
20343:
20344: /**
20345: * Execute a callback over each item while chunking by ID.
20346: *
20347: * @param callable $callback
20348: * @param int $count
20349: * @param string|null $column
20350: * @param string|null $alias
20351: * @return bool
20352: * @static
20353: */
20354: public static function eachById($callback, $count = 1000, $column = null, $alias = null)
20355: {
20356: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20357: return $instance->eachById($callback, $count, $column, $alias);
20358: }
20359:
20360: /**
20361: * Query lazily, by chunks of the given size.
20362: *
20363: * @param int $chunkSize
20364: * @return \Illuminate\Support\LazyCollection
20365: * @throws \InvalidArgumentException
20366: * @static
20367: */
20368: public static function lazy($chunkSize = 1000)
20369: {
20370: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20371: return $instance->lazy($chunkSize);
20372: }
20373:
20374: /**
20375: * Query lazily, by chunking the results of a query by comparing IDs.
20376: *
20377: * @param int $chunkSize
20378: * @param string|null $column
20379: * @param string|null $alias
20380: * @return \Illuminate\Support\LazyCollection
20381: * @throws \InvalidArgumentException
20382: * @static
20383: */
20384: public static function lazyById($chunkSize = 1000, $column = null, $alias = null)
20385: {
20386: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20387: return $instance->lazyById($chunkSize, $column, $alias);
20388: }
20389:
20390: /**
20391: * Query lazily, by chunking the results of a query by comparing IDs in descending order.
20392: *
20393: * @param int $chunkSize
20394: * @param string|null $column
20395: * @param string|null $alias
20396: * @return \Illuminate\Support\LazyCollection
20397: * @throws \InvalidArgumentException
20398: * @static
20399: */
20400: public static function lazyByIdDesc($chunkSize = 1000, $column = null, $alias = null)
20401: {
20402: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20403: return $instance->lazyByIdDesc($chunkSize, $column, $alias);
20404: }
20405:
20406: /**
20407: * Execute the query and get the first result.
20408: *
20409: * @param array|string $columns
20410: * @return \Illuminate\Database\Eloquent\Model|object|static|null
20411: * @static
20412: */
20413: public static function first($columns = [])
20414: {
20415: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20416: return $instance->first($columns);
20417: }
20418:
20419: /**
20420: * Execute the query and get the first result if it's the sole matching record.
20421: *
20422: * @param array|string $columns
20423: * @return \Illuminate\Database\Eloquent\Model|object|static|null
20424: * @throws \Illuminate\Database\RecordsNotFoundException
20425: * @throws \Illuminate\Database\MultipleRecordsFoundException
20426: * @static
20427: */
20428: public static function baseSole($columns = [])
20429: {
20430: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20431: return $instance->baseSole($columns);
20432: }
20433:
20434: /**
20435: * Pass the query to a given callback.
20436: *
20437: * @param callable $callback
20438: * @return \Illuminate\Database\Eloquent\Builder|static
20439: * @static
20440: */
20441: public static function tap($callback)
20442: {
20443: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20444: return $instance->tap($callback);
20445: }
20446:
20447: /**
20448: * Apply the callback if the given "value" is (or resolves to) truthy.
20449: *
20450: * @template TWhenParameter
20451: * @template TWhenReturnType
20452: * @param \Illuminate\Database\Eloquent\(\Closure($this): TWhenParameter)|TWhenParameter $value
20453: * @param \Illuminate\Database\Eloquent\(callable($this, TWhenParameter): TWhenReturnType)|null $callback
20454: * @param \Illuminate\Database\Eloquent\(callable($this, TWhenParameter): TWhenReturnType)|null $default
20455: * @return $this|\Illuminate\Database\Eloquent\TWhenReturnType
20456: * @static
20457: */
20458: public static function when($value, $callback = null, $default = null)
20459: {
20460: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20461: return $instance->when($value, $callback, $default);
20462: }
20463:
20464: /**
20465: * Apply the callback if the given "value" is (or resolves to) falsy.
20466: *
20467: * @template TUnlessParameter
20468: * @template TUnlessReturnType
20469: * @param \Illuminate\Database\Eloquent\(\Closure($this): TUnlessParameter)|TUnlessParameter $value
20470: * @param \Illuminate\Database\Eloquent\(callable($this, TUnlessParameter): TUnlessReturnType)|null $callback
20471: * @param \Illuminate\Database\Eloquent\(callable($this, TUnlessParameter): TUnlessReturnType)|null $default
20472: * @return $this|\Illuminate\Database\Eloquent\TUnlessReturnType
20473: * @static
20474: */
20475: public static function unless($value, $callback = null, $default = null)
20476: {
20477: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20478: return $instance->unless($value, $callback, $default);
20479: }
20480:
20481: /**
20482: * Add a relationship count / exists condition to the query.
20483: *
20484: * @param \Illuminate\Database\Eloquent\Relations\Relation|string $relation
20485: * @param string $operator
20486: * @param int $count
20487: * @param string $boolean
20488: * @param \Closure|null $callback
20489: * @return \Illuminate\Database\Eloquent\Builder|static
20490: * @throws \RuntimeException
20491: * @static
20492: */
20493: public static function has($relation, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
20494: {
20495: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20496: return $instance->has($relation, $operator, $count, $boolean, $callback);
20497: }
20498:
20499: /**
20500: * Add a relationship count / exists condition to the query with an "or".
20501: *
20502: * @param string $relation
20503: * @param string $operator
20504: * @param int $count
20505: * @return \Illuminate\Database\Eloquent\Builder|static
20506: * @static
20507: */
20508: public static function orHas($relation, $operator = '>=', $count = 1)
20509: {
20510: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20511: return $instance->orHas($relation, $operator, $count);
20512: }
20513:
20514: /**
20515: * Add a relationship count / exists condition to the query.
20516: *
20517: * @param string $relation
20518: * @param string $boolean
20519: * @param \Closure|null $callback
20520: * @return \Illuminate\Database\Eloquent\Builder|static
20521: * @static
20522: */
20523: public static function doesntHave($relation, $boolean = 'and', $callback = null)
20524: {
20525: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20526: return $instance->doesntHave($relation, $boolean, $callback);
20527: }
20528:
20529: /**
20530: * Add a relationship count / exists condition to the query with an "or".
20531: *
20532: * @param string $relation
20533: * @return \Illuminate\Database\Eloquent\Builder|static
20534: * @static
20535: */
20536: public static function orDoesntHave($relation)
20537: {
20538: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20539: return $instance->orDoesntHave($relation);
20540: }
20541:
20542: /**
20543: * Add a relationship count / exists condition to the query with where clauses.
20544: *
20545: * @param string $relation
20546: * @param \Closure|null $callback
20547: * @param string $operator
20548: * @param int $count
20549: * @return \Illuminate\Database\Eloquent\Builder|static
20550: * @static
20551: */
20552: public static function whereHas($relation, $callback = null, $operator = '>=', $count = 1)
20553: {
20554: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20555: return $instance->whereHas($relation, $callback, $operator, $count);
20556: }
20557:
20558: /**
20559: * Add a relationship count / exists condition to the query with where clauses.
20560: *
20561: * Also load the relationship with same condition.
20562: *
20563: * @param string $relation
20564: * @param \Closure|null $callback
20565: * @param string $operator
20566: * @param int $count
20567: * @return \Illuminate\Database\Eloquent\Builder|static
20568: * @static
20569: */
20570: public static function withWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
20571: {
20572: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20573: return $instance->withWhereHas($relation, $callback, $operator, $count);
20574: }
20575:
20576: /**
20577: * Add a relationship count / exists condition to the query with where clauses and an "or".
20578: *
20579: * @param string $relation
20580: * @param \Closure|null $callback
20581: * @param string $operator
20582: * @param int $count
20583: * @return \Illuminate\Database\Eloquent\Builder|static
20584: * @static
20585: */
20586: public static function orWhereHas($relation, $callback = null, $operator = '>=', $count = 1)
20587: {
20588: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20589: return $instance->orWhereHas($relation, $callback, $operator, $count);
20590: }
20591:
20592: /**
20593: * Add a relationship count / exists condition to the query with where clauses.
20594: *
20595: * @param string $relation
20596: * @param \Closure|null $callback
20597: * @return \Illuminate\Database\Eloquent\Builder|static
20598: * @static
20599: */
20600: public static function whereDoesntHave($relation, $callback = null)
20601: {
20602: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20603: return $instance->whereDoesntHave($relation, $callback);
20604: }
20605:
20606: /**
20607: * Add a relationship count / exists condition to the query with where clauses and an "or".
20608: *
20609: * @param string $relation
20610: * @param \Closure|null $callback
20611: * @return \Illuminate\Database\Eloquent\Builder|static
20612: * @static
20613: */
20614: public static function orWhereDoesntHave($relation, $callback = null)
20615: {
20616: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20617: return $instance->orWhereDoesntHave($relation, $callback);
20618: }
20619:
20620: /**
20621: * Add a polymorphic relationship count / exists condition to the query.
20622: *
20623: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20624: * @param string|array $types
20625: * @param string $operator
20626: * @param int $count
20627: * @param string $boolean
20628: * @param \Closure|null $callback
20629: * @return \Illuminate\Database\Eloquent\Builder|static
20630: * @static
20631: */
20632: public static function hasMorph($relation, $types, $operator = '>=', $count = 1, $boolean = 'and', $callback = null)
20633: {
20634: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20635: return $instance->hasMorph($relation, $types, $operator, $count, $boolean, $callback);
20636: }
20637:
20638: /**
20639: * Add a polymorphic relationship count / exists condition to the query with an "or".
20640: *
20641: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20642: * @param string|array $types
20643: * @param string $operator
20644: * @param int $count
20645: * @return \Illuminate\Database\Eloquent\Builder|static
20646: * @static
20647: */
20648: public static function orHasMorph($relation, $types, $operator = '>=', $count = 1)
20649: {
20650: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20651: return $instance->orHasMorph($relation, $types, $operator, $count);
20652: }
20653:
20654: /**
20655: * Add a polymorphic relationship count / exists condition to the query.
20656: *
20657: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20658: * @param string|array $types
20659: * @param string $boolean
20660: * @param \Closure|null $callback
20661: * @return \Illuminate\Database\Eloquent\Builder|static
20662: * @static
20663: */
20664: public static function doesntHaveMorph($relation, $types, $boolean = 'and', $callback = null)
20665: {
20666: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20667: return $instance->doesntHaveMorph($relation, $types, $boolean, $callback);
20668: }
20669:
20670: /**
20671: * Add a polymorphic relationship count / exists condition to the query with an "or".
20672: *
20673: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20674: * @param string|array $types
20675: * @return \Illuminate\Database\Eloquent\Builder|static
20676: * @static
20677: */
20678: public static function orDoesntHaveMorph($relation, $types)
20679: {
20680: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20681: return $instance->orDoesntHaveMorph($relation, $types);
20682: }
20683:
20684: /**
20685: * Add a polymorphic relationship count / exists condition to the query with where clauses.
20686: *
20687: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20688: * @param string|array $types
20689: * @param \Closure|null $callback
20690: * @param string $operator
20691: * @param int $count
20692: * @return \Illuminate\Database\Eloquent\Builder|static
20693: * @static
20694: */
20695: public static function whereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1)
20696: {
20697: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20698: return $instance->whereHasMorph($relation, $types, $callback, $operator, $count);
20699: }
20700:
20701: /**
20702: * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or".
20703: *
20704: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20705: * @param string|array $types
20706: * @param \Closure|null $callback
20707: * @param string $operator
20708: * @param int $count
20709: * @return \Illuminate\Database\Eloquent\Builder|static
20710: * @static
20711: */
20712: public static function orWhereHasMorph($relation, $types, $callback = null, $operator = '>=', $count = 1)
20713: {
20714: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20715: return $instance->orWhereHasMorph($relation, $types, $callback, $operator, $count);
20716: }
20717:
20718: /**
20719: * Add a polymorphic relationship count / exists condition to the query with where clauses.
20720: *
20721: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20722: * @param string|array $types
20723: * @param \Closure|null $callback
20724: * @return \Illuminate\Database\Eloquent\Builder|static
20725: * @static
20726: */
20727: public static function whereDoesntHaveMorph($relation, $types, $callback = null)
20728: {
20729: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20730: return $instance->whereDoesntHaveMorph($relation, $types, $callback);
20731: }
20732:
20733: /**
20734: * Add a polymorphic relationship count / exists condition to the query with where clauses and an "or".
20735: *
20736: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20737: * @param string|array $types
20738: * @param \Closure|null $callback
20739: * @return \Illuminate\Database\Eloquent\Builder|static
20740: * @static
20741: */
20742: public static function orWhereDoesntHaveMorph($relation, $types, $callback = null)
20743: {
20744: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20745: return $instance->orWhereDoesntHaveMorph($relation, $types, $callback);
20746: }
20747:
20748: /**
20749: * Add a basic where clause to a relationship query.
20750: *
20751: * @param string $relation
20752: * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20753: * @param mixed $operator
20754: * @param mixed $value
20755: * @return \Illuminate\Database\Eloquent\Builder|static
20756: * @static
20757: */
20758: public static function whereRelation($relation, $column, $operator = null, $value = null)
20759: {
20760: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20761: return $instance->whereRelation($relation, $column, $operator, $value);
20762: }
20763:
20764: /**
20765: * Add an "or where" clause to a relationship query.
20766: *
20767: * @param string $relation
20768: * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20769: * @param mixed $operator
20770: * @param mixed $value
20771: * @return \Illuminate\Database\Eloquent\Builder|static
20772: * @static
20773: */
20774: public static function orWhereRelation($relation, $column, $operator = null, $value = null)
20775: {
20776: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20777: return $instance->orWhereRelation($relation, $column, $operator, $value);
20778: }
20779:
20780: /**
20781: * Add a polymorphic relationship condition to the query with a where clause.
20782: *
20783: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20784: * @param string|array $types
20785: * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20786: * @param mixed $operator
20787: * @param mixed $value
20788: * @return \Illuminate\Database\Eloquent\Builder|static
20789: * @static
20790: */
20791: public static function whereMorphRelation($relation, $types, $column, $operator = null, $value = null)
20792: {
20793: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20794: return $instance->whereMorphRelation($relation, $types, $column, $operator, $value);
20795: }
20796:
20797: /**
20798: * Add a polymorphic relationship condition to the query with an "or where" clause.
20799: *
20800: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20801: * @param string|array $types
20802: * @param \Closure|string|array|\Illuminate\Database\Query\Expression $column
20803: * @param mixed $operator
20804: * @param mixed $value
20805: * @return \Illuminate\Database\Eloquent\Builder|static
20806: * @static
20807: */
20808: public static function orWhereMorphRelation($relation, $types, $column, $operator = null, $value = null)
20809: {
20810: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20811: return $instance->orWhereMorphRelation($relation, $types, $column, $operator, $value);
20812: }
20813:
20814: /**
20815: * Add a morph-to relationship condition to the query.
20816: *
20817: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20818: * @param \Illuminate\Database\Eloquent\Model|string $model
20819: * @return \Illuminate\Database\Eloquent\Builder|static
20820: * @static
20821: */
20822: public static function whereMorphedTo($relation, $model, $boolean = 'and')
20823: {
20824: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20825: return $instance->whereMorphedTo($relation, $model, $boolean);
20826: }
20827:
20828: /**
20829: * Add a not morph-to relationship condition to the query.
20830: *
20831: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20832: * @param \Illuminate\Database\Eloquent\Model|string $model
20833: * @return \Illuminate\Database\Eloquent\Builder|static
20834: * @static
20835: */
20836: public static function whereNotMorphedTo($relation, $model, $boolean = 'and')
20837: {
20838: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20839: return $instance->whereNotMorphedTo($relation, $model, $boolean);
20840: }
20841:
20842: /**
20843: * Add a morph-to relationship condition to the query with an "or where" clause.
20844: *
20845: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20846: * @param \Illuminate\Database\Eloquent\Model|string $model
20847: * @return \Illuminate\Database\Eloquent\Builder|static
20848: * @static
20849: */
20850: public static function orWhereMorphedTo($relation, $model)
20851: {
20852: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20853: return $instance->orWhereMorphedTo($relation, $model);
20854: }
20855:
20856: /**
20857: * Add a not morph-to relationship condition to the query with an "or where" clause.
20858: *
20859: * @param \Illuminate\Database\Eloquent\Relations\MorphTo|string $relation
20860: * @param \Illuminate\Database\Eloquent\Model|string $model
20861: * @return \Illuminate\Database\Eloquent\Builder|static
20862: * @static
20863: */
20864: public static function orWhereNotMorphedTo($relation, $model)
20865: {
20866: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20867: return $instance->orWhereNotMorphedTo($relation, $model);
20868: }
20869:
20870: /**
20871: * Add a "belongs to" relationship where clause to the query.
20872: *
20873: * @param \Illuminate\Database\Eloquent\Model|\Illuminate\Database\Eloquent\Collection<\Illuminate\Database\Eloquent\Model> $related
20874: * @param string|null $relationshipName
20875: * @param string $boolean
20876: * @return \Illuminate\Database\Eloquent\Builder|static
20877: * @throws \Illuminate\Database\Eloquent\RelationNotFoundException
20878: * @static
20879: */
20880: public static function whereBelongsTo($related, $relationshipName = null, $boolean = 'and')
20881: {
20882: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20883: return $instance->whereBelongsTo($related, $relationshipName, $boolean);
20884: }
20885:
20886: /**
20887: * Add an "BelongsTo" relationship with an "or where" clause to the query.
20888: *
20889: * @param \Illuminate\Database\Eloquent\Model $related
20890: * @param string|null $relationshipName
20891: * @return \Illuminate\Database\Eloquent\Builder|static
20892: * @throws \RuntimeException
20893: * @static
20894: */
20895: public static function orWhereBelongsTo($related, $relationshipName = null)
20896: {
20897: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20898: return $instance->orWhereBelongsTo($related, $relationshipName);
20899: }
20900:
20901: /**
20902: * Add subselect queries to include an aggregate value for a relationship.
20903: *
20904: * @param mixed $relations
20905: * @param string $column
20906: * @param string $function
20907: * @return \Illuminate\Database\Eloquent\Builder|static
20908: * @static
20909: */
20910: public static function withAggregate($relations, $column, $function = null)
20911: {
20912: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20913: return $instance->withAggregate($relations, $column, $function);
20914: }
20915:
20916: /**
20917: * Add subselect queries to count the relations.
20918: *
20919: * @param mixed $relations
20920: * @return \Illuminate\Database\Eloquent\Builder|static
20921: * @static
20922: */
20923: public static function withCount($relations)
20924: {
20925: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20926: return $instance->withCount($relations);
20927: }
20928:
20929: /**
20930: * Add subselect queries to include the max of the relation's column.
20931: *
20932: * @param string|array $relation
20933: * @param string $column
20934: * @return \Illuminate\Database\Eloquent\Builder|static
20935: * @static
20936: */
20937: public static function withMax($relation, $column)
20938: {
20939: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20940: return $instance->withMax($relation, $column);
20941: }
20942:
20943: /**
20944: * Add subselect queries to include the min of the relation's column.
20945: *
20946: * @param string|array $relation
20947: * @param string $column
20948: * @return \Illuminate\Database\Eloquent\Builder|static
20949: * @static
20950: */
20951: public static function withMin($relation, $column)
20952: {
20953: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20954: return $instance->withMin($relation, $column);
20955: }
20956:
20957: /**
20958: * Add subselect queries to include the sum of the relation's column.
20959: *
20960: * @param string|array $relation
20961: * @param string $column
20962: * @return \Illuminate\Database\Eloquent\Builder|static
20963: * @static
20964: */
20965: public static function withSum($relation, $column)
20966: {
20967: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20968: return $instance->withSum($relation, $column);
20969: }
20970:
20971: /**
20972: * Add subselect queries to include the average of the relation's column.
20973: *
20974: * @param string|array $relation
20975: * @param string $column
20976: * @return \Illuminate\Database\Eloquent\Builder|static
20977: * @static
20978: */
20979: public static function withAvg($relation, $column)
20980: {
20981: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20982: return $instance->withAvg($relation, $column);
20983: }
20984:
20985: /**
20986: * Add subselect queries to include the existence of related models.
20987: *
20988: * @param string|array $relation
20989: * @return \Illuminate\Database\Eloquent\Builder|static
20990: * @static
20991: */
20992: public static function withExists($relation)
20993: {
20994: /** @var \Illuminate\Database\Eloquent\Builder $instance */
20995: return $instance->withExists($relation);
20996: }
20997:
20998: /**
20999: * Merge the where constraints from another query to the current query.
21000: *
21001: * @param \Illuminate\Database\Eloquent\Builder $from
21002: * @return \Illuminate\Database\Eloquent\Builder|static
21003: * @static
21004: */
21005: public static function mergeConstraintsFrom($from)
21006: {
21007: /** @var \Illuminate\Database\Eloquent\Builder $instance */
21008: return $instance->mergeConstraintsFrom($from);
21009: }
21010:
21011: /**
21012: * Set the columns to be selected.
21013: *
21014: * @param array|mixed $columns
21015: * @return \Illuminate\Database\Query\Builder
21016: * @static
21017: */
21018: public static function select($columns = [])
21019: {
21020: /** @var \Illuminate\Database\Query\Builder $instance */
21021: return $instance->select($columns);
21022: }
21023:
21024: /**
21025: * Add a subselect expression to the query.
21026: *
21027: * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
21028: * @param string $as
21029: * @return \Illuminate\Database\Query\Builder
21030: * @throws \InvalidArgumentException
21031: * @static
21032: */
21033: public static function selectSub($query, $as)
21034: {
21035: /** @var \Illuminate\Database\Query\Builder $instance */
21036: return $instance->selectSub($query, $as);
21037: }
21038:
21039: /**
21040: * Add a new "raw" select expression to the query.
21041: *
21042: * @param string $expression
21043: * @param array $bindings
21044: * @return \Illuminate\Database\Query\Builder
21045: * @static
21046: */
21047: public static function selectRaw($expression, $bindings = [])
21048: {
21049: /** @var \Illuminate\Database\Query\Builder $instance */
21050: return $instance->selectRaw($expression, $bindings);
21051: }
21052:
21053: /**
21054: * Makes "from" fetch from a subquery.
21055: *
21056: * @param \Closure|\Illuminate\Database\Query\Builder|string $query
21057: * @param string $as
21058: * @return \Illuminate\Database\Query\Builder
21059: * @throws \InvalidArgumentException
21060: * @static
21061: */
21062: public static function fromSub($query, $as)
21063: {
21064: /** @var \Illuminate\Database\Query\Builder $instance */
21065: return $instance->fromSub($query, $as);
21066: }
21067:
21068: /**
21069: * Add a raw from clause to the query.
21070: *
21071: * @param string $expression
21072: * @param mixed $bindings
21073: * @return \Illuminate\Database\Query\Builder
21074: * @static
21075: */
21076: public static function fromRaw($expression, $bindings = [])
21077: {
21078: /** @var \Illuminate\Database\Query\Builder $instance */
21079: return $instance->fromRaw($expression, $bindings);
21080: }
21081:
21082: /**
21083: * Add a new select column to the query.
21084: *
21085: * @param array|mixed $column
21086: * @return \Illuminate\Database\Query\Builder
21087: * @static
21088: */
21089: public static function addSelect($column)
21090: {
21091: /** @var \Illuminate\Database\Query\Builder $instance */
21092: return $instance->addSelect($column);
21093: }
21094:
21095: /**
21096: * Force the query to only return distinct results.
21097: *
21098: * @return \Illuminate\Database\Query\Builder
21099: * @static
21100: */
21101: public static function distinct()
21102: {
21103: /** @var \Illuminate\Database\Query\Builder $instance */
21104: return $instance->distinct();
21105: }
21106:
21107: /**
21108: * Set the table which the query is targeting.
21109: *
21110: * @param \Closure|\Illuminate\Database\Query\Builder|string $table
21111: * @param string|null $as
21112: * @return \Illuminate\Database\Query\Builder
21113: * @static
21114: */
21115: public static function from($table, $as = null)
21116: {
21117: /** @var \Illuminate\Database\Query\Builder $instance */
21118: return $instance->from($table, $as);
21119: }
21120:
21121: /**
21122: * Add a join clause to the query.
21123: *
21124: * @param string $table
21125: * @param \Closure|string $first
21126: * @param string|null $operator
21127: * @param string|null $second
21128: * @param string $type
21129: * @param bool $where
21130: * @return \Illuminate\Database\Query\Builder
21131: * @static
21132: */
21133: public static function join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false)
21134: {
21135: /** @var \Illuminate\Database\Query\Builder $instance */
21136: return $instance->join($table, $first, $operator, $second, $type, $where);
21137: }
21138:
21139: /**
21140: * Add a "join where" clause to the query.
21141: *
21142: * @param string $table
21143: * @param \Closure|string $first
21144: * @param string $operator
21145: * @param string $second
21146: * @param string $type
21147: * @return \Illuminate\Database\Query\Builder
21148: * @static
21149: */
21150: public static function joinWhere($table, $first, $operator, $second, $type = 'inner')
21151: {
21152: /** @var \Illuminate\Database\Query\Builder $instance */
21153: return $instance->joinWhere($table, $first, $operator, $second, $type);
21154: }
21155:
21156: /**
21157: * Add a subquery join clause to the query.
21158: *
21159: * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
21160: * @param string $as
21161: * @param \Closure|string $first
21162: * @param string|null $operator
21163: * @param string|null $second
21164: * @param string $type
21165: * @param bool $where
21166: * @return \Illuminate\Database\Query\Builder
21167: * @throws \InvalidArgumentException
21168: * @static
21169: */
21170: public static function joinSub($query, $as, $first, $operator = null, $second = null, $type = 'inner', $where = false)
21171: {
21172: /** @var \Illuminate\Database\Query\Builder $instance */
21173: return $instance->joinSub($query, $as, $first, $operator, $second, $type, $where);
21174: }
21175:
21176: /**
21177: * Add a left join to the query.
21178: *
21179: * @param string $table
21180: * @param \Closure|string $first
21181: * @param string|null $operator
21182: * @param string|null $second
21183: * @return \Illuminate\Database\Query\Builder
21184: * @static
21185: */
21186: public static function leftJoin($table, $first, $operator = null, $second = null)
21187: {
21188: /** @var \Illuminate\Database\Query\Builder $instance */
21189: return $instance->leftJoin($table, $first, $operator, $second);
21190: }
21191:
21192: /**
21193: * Add a "join where" clause to the query.
21194: *
21195: * @param string $table
21196: * @param \Closure|string $first
21197: * @param string $operator
21198: * @param string $second
21199: * @return \Illuminate\Database\Query\Builder
21200: * @static
21201: */
21202: public static function leftJoinWhere($table, $first, $operator, $second)
21203: {
21204: /** @var \Illuminate\Database\Query\Builder $instance */
21205: return $instance->leftJoinWhere($table, $first, $operator, $second);
21206: }
21207:
21208: /**
21209: * Add a subquery left join to the query.
21210: *
21211: * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
21212: * @param string $as
21213: * @param \Closure|string $first
21214: * @param string|null $operator
21215: * @param string|null $second
21216: * @return \Illuminate\Database\Query\Builder
21217: * @static
21218: */
21219: public static function leftJoinSub($query, $as, $first, $operator = null, $second = null)
21220: {
21221: /** @var \Illuminate\Database\Query\Builder $instance */
21222: return $instance->leftJoinSub($query, $as, $first, $operator, $second);
21223: }
21224:
21225: /**
21226: * Add a right join to the query.
21227: *
21228: * @param string $table
21229: * @param \Closure|string $first
21230: * @param string|null $operator
21231: * @param string|null $second
21232: * @return \Illuminate\Database\Query\Builder
21233: * @static
21234: */
21235: public static function rightJoin($table, $first, $operator = null, $second = null)
21236: {
21237: /** @var \Illuminate\Database\Query\Builder $instance */
21238: return $instance->rightJoin($table, $first, $operator, $second);
21239: }
21240:
21241: /**
21242: * Add a "right join where" clause to the query.
21243: *
21244: * @param string $table
21245: * @param \Closure|string $first
21246: * @param string $operator
21247: * @param string $second
21248: * @return \Illuminate\Database\Query\Builder
21249: * @static
21250: */
21251: public static function rightJoinWhere($table, $first, $operator, $second)
21252: {
21253: /** @var \Illuminate\Database\Query\Builder $instance */
21254: return $instance->rightJoinWhere($table, $first, $operator, $second);
21255: }
21256:
21257: /**
21258: * Add a subquery right join to the query.
21259: *
21260: * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|string $query
21261: * @param string $as
21262: * @param \Closure|string $first
21263: * @param string|null $operator
21264: * @param string|null $second
21265: * @return \Illuminate\Database\Query\Builder
21266: * @static
21267: */
21268: public static function rightJoinSub($query, $as, $first, $operator = null, $second = null)
21269: {
21270: /** @var \Illuminate\Database\Query\Builder $instance */
21271: return $instance->rightJoinSub($query, $as, $first, $operator, $second);
21272: }
21273:
21274: /**
21275: * Add a "cross join" clause to the query.
21276: *
21277: * @param string $table
21278: * @param \Closure|string|null $first
21279: * @param string|null $operator
21280: * @param string|null $second
21281: * @return \Illuminate\Database\Query\Builder
21282: * @static
21283: */
21284: public static function crossJoin($table, $first = null, $operator = null, $second = null)
21285: {
21286: /** @var \Illuminate\Database\Query\Builder $instance */
21287: return $instance->crossJoin($table, $first, $operator, $second);
21288: }
21289:
21290: /**
21291: * Add a subquery cross join to the query.
21292: *
21293: * @param \Closure|\Illuminate\Database\Query\Builder|string $query
21294: * @param string $as
21295: * @return \Illuminate\Database\Query\Builder
21296: * @static
21297: */
21298: public static function crossJoinSub($query, $as)
21299: {
21300: /** @var \Illuminate\Database\Query\Builder $instance */
21301: return $instance->crossJoinSub($query, $as);
21302: }
21303:
21304: /**
21305: * Merge an array of where clauses and bindings.
21306: *
21307: * @param array $wheres
21308: * @param array $bindings
21309: * @return \Illuminate\Database\Query\Builder
21310: * @static
21311: */
21312: public static function mergeWheres($wheres, $bindings)
21313: {
21314: /** @var \Illuminate\Database\Query\Builder $instance */
21315: return $instance->mergeWheres($wheres, $bindings);
21316: }
21317:
21318: /**
21319: * Prepare the value and operator for a where clause.
21320: *
21321: * @param string $value
21322: * @param string $operator
21323: * @param bool $useDefault
21324: * @return array
21325: * @throws \InvalidArgumentException
21326: * @static
21327: */
21328: public static function prepareValueAndOperator($value, $operator, $useDefault = false)
21329: {
21330: /** @var \Illuminate\Database\Query\Builder $instance */
21331: return $instance->prepareValueAndOperator($value, $operator, $useDefault);
21332: }
21333:
21334: /**
21335: * Add a "where" clause comparing two columns to the query.
21336: *
21337: * @param string|array $first
21338: * @param string|null $operator
21339: * @param string|null $second
21340: * @param string|null $boolean
21341: * @return \Illuminate\Database\Query\Builder
21342: * @static
21343: */
21344: public static function whereColumn($first, $operator = null, $second = null, $boolean = 'and')
21345: {
21346: /** @var \Illuminate\Database\Query\Builder $instance */
21347: return $instance->whereColumn($first, $operator, $second, $boolean);
21348: }
21349:
21350: /**
21351: * Add an "or where" clause comparing two columns to the query.
21352: *
21353: * @param string|array $first
21354: * @param string|null $operator
21355: * @param string|null $second
21356: * @return \Illuminate\Database\Query\Builder
21357: * @static
21358: */
21359: public static function orWhereColumn($first, $operator = null, $second = null)
21360: {
21361: /** @var \Illuminate\Database\Query\Builder $instance */
21362: return $instance->orWhereColumn($first, $operator, $second);
21363: }
21364:
21365: /**
21366: * Add a raw where clause to the query.
21367: *
21368: * @param string $sql
21369: * @param mixed $bindings
21370: * @param string $boolean
21371: * @return \Illuminate\Database\Query\Builder
21372: * @static
21373: */
21374: public static function whereRaw($sql, $bindings = [], $boolean = 'and')
21375: {
21376: /** @var \Illuminate\Database\Query\Builder $instance */
21377: return $instance->whereRaw($sql, $bindings, $boolean);
21378: }
21379:
21380: /**
21381: * Add a raw or where clause to the query.
21382: *
21383: * @param string $sql
21384: * @param mixed $bindings
21385: * @return \Illuminate\Database\Query\Builder
21386: * @static
21387: */
21388: public static function orWhereRaw($sql, $bindings = [])
21389: {
21390: /** @var \Illuminate\Database\Query\Builder $instance */
21391: return $instance->orWhereRaw($sql, $bindings);
21392: }
21393:
21394: /**
21395: * Add a "where in" clause to the query.
21396: *
21397: * @param string $column
21398: * @param mixed $values
21399: * @param string $boolean
21400: * @param bool $not
21401: * @return \Illuminate\Database\Query\Builder
21402: * @static
21403: */
21404: public static function whereIn($column, $values, $boolean = 'and', $not = false)
21405: {
21406: /** @var \Illuminate\Database\Query\Builder $instance */
21407: return $instance->whereIn($column, $values, $boolean, $not);
21408: }
21409:
21410: /**
21411: * Add an "or where in" clause to the query.
21412: *
21413: * @param string $column
21414: * @param mixed $values
21415: * @return \Illuminate\Database\Query\Builder
21416: * @static
21417: */
21418: public static function orWhereIn($column, $values)
21419: {
21420: /** @var \Illuminate\Database\Query\Builder $instance */
21421: return $instance->orWhereIn($column, $values);
21422: }
21423:
21424: /**
21425: * Add a "where not in" clause to the query.
21426: *
21427: * @param string $column
21428: * @param mixed $values
21429: * @param string $boolean
21430: * @return \Illuminate\Database\Query\Builder
21431: * @static
21432: */
21433: public static function whereNotIn($column, $values, $boolean = 'and')
21434: {
21435: /** @var \Illuminate\Database\Query\Builder $instance */
21436: return $instance->whereNotIn($column, $values, $boolean);
21437: }
21438:
21439: /**
21440: * Add an "or where not in" clause to the query.
21441: *
21442: * @param string $column
21443: * @param mixed $values
21444: * @return \Illuminate\Database\Query\Builder
21445: * @static
21446: */
21447: public static function orWhereNotIn($column, $values)
21448: {
21449: /** @var \Illuminate\Database\Query\Builder $instance */
21450: return $instance->orWhereNotIn($column, $values);
21451: }
21452:
21453: /**
21454: * Add a "where in raw" clause for integer values to the query.
21455: *
21456: * @param string $column
21457: * @param \Illuminate\Contracts\Support\Arrayable|array $values
21458: * @param string $boolean
21459: * @param bool $not
21460: * @return \Illuminate\Database\Query\Builder
21461: * @static
21462: */
21463: public static function whereIntegerInRaw($column, $values, $boolean = 'and', $not = false)
21464: {
21465: /** @var \Illuminate\Database\Query\Builder $instance */
21466: return $instance->whereIntegerInRaw($column, $values, $boolean, $not);
21467: }
21468:
21469: /**
21470: * Add an "or where in raw" clause for integer values to the query.
21471: *
21472: * @param string $column
21473: * @param \Illuminate\Contracts\Support\Arrayable|array $values
21474: * @return \Illuminate\Database\Query\Builder
21475: * @static
21476: */
21477: public static function orWhereIntegerInRaw($column, $values)
21478: {
21479: /** @var \Illuminate\Database\Query\Builder $instance */
21480: return $instance->orWhereIntegerInRaw($column, $values);
21481: }
21482:
21483: /**
21484: * Add a "where not in raw" clause for integer values to the query.
21485: *
21486: * @param string $column
21487: * @param \Illuminate\Contracts\Support\Arrayable|array $values
21488: * @param string $boolean
21489: * @return \Illuminate\Database\Query\Builder
21490: * @static
21491: */
21492: public static function whereIntegerNotInRaw($column, $values, $boolean = 'and')
21493: {
21494: /** @var \Illuminate\Database\Query\Builder $instance */
21495: return $instance->whereIntegerNotInRaw($column, $values, $boolean);
21496: }
21497:
21498: /**
21499: * Add an "or where not in raw" clause for integer values to the query.
21500: *
21501: * @param string $column
21502: * @param \Illuminate\Contracts\Support\Arrayable|array $values
21503: * @return \Illuminate\Database\Query\Builder
21504: * @static
21505: */
21506: public static function orWhereIntegerNotInRaw($column, $values)
21507: {
21508: /** @var \Illuminate\Database\Query\Builder $instance */
21509: return $instance->orWhereIntegerNotInRaw($column, $values);
21510: }
21511:
21512: /**
21513: * Add a "where null" clause to the query.
21514: *
21515: * @param string|array $columns
21516: * @param string $boolean
21517: * @param bool $not
21518: * @return \Illuminate\Database\Query\Builder
21519: * @static
21520: */
21521: public static function whereNull($columns, $boolean = 'and', $not = false)
21522: {
21523: /** @var \Illuminate\Database\Query\Builder $instance */
21524: return $instance->whereNull($columns, $boolean, $not);
21525: }
21526:
21527: /**
21528: * Add an "or where null" clause to the query.
21529: *
21530: * @param string|array $column
21531: * @return \Illuminate\Database\Query\Builder
21532: * @static
21533: */
21534: public static function orWhereNull($column)
21535: {
21536: /** @var \Illuminate\Database\Query\Builder $instance */
21537: return $instance->orWhereNull($column);
21538: }
21539:
21540: /**
21541: * Add a "where not null" clause to the query.
21542: *
21543: * @param string|array $columns
21544: * @param string $boolean
21545: * @return \Illuminate\Database\Query\Builder
21546: * @static
21547: */
21548: public static function whereNotNull($columns, $boolean = 'and')
21549: {
21550: /** @var \Illuminate\Database\Query\Builder $instance */
21551: return $instance->whereNotNull($columns, $boolean);
21552: }
21553:
21554: /**
21555: * Add a where between statement to the query.
21556: *
21557: * @param string|\Illuminate\Database\Query\Expression $column
21558: * @param \Illuminate\Database\Query\iterable $values
21559: * @param string $boolean
21560: * @param bool $not
21561: * @return \Illuminate\Database\Query\Builder
21562: * @static
21563: */
21564: public static function whereBetween($column, $values, $boolean = 'and', $not = false)
21565: {
21566: /** @var \Illuminate\Database\Query\Builder $instance */
21567: return $instance->whereBetween($column, $values, $boolean, $not);
21568: }
21569:
21570: /**
21571: * Add a where between statement using columns to the query.
21572: *
21573: * @param string $column
21574: * @param array $values
21575: * @param string $boolean
21576: * @param bool $not
21577: * @return \Illuminate\Database\Query\Builder
21578: * @static
21579: */
21580: public static function whereBetweenColumns($column, $values, $boolean = 'and', $not = false)
21581: {
21582: /** @var \Illuminate\Database\Query\Builder $instance */
21583: return $instance->whereBetweenColumns($column, $values, $boolean, $not);
21584: }
21585:
21586: /**
21587: * Add an or where between statement to the query.
21588: *
21589: * @param string $column
21590: * @param \Illuminate\Database\Query\iterable $values
21591: * @return \Illuminate\Database\Query\Builder
21592: * @static
21593: */
21594: public static function orWhereBetween($column, $values)
21595: {
21596: /** @var \Illuminate\Database\Query\Builder $instance */
21597: return $instance->orWhereBetween($column, $values);
21598: }
21599:
21600: /**
21601: * Add an or where between statement using columns to the query.
21602: *
21603: * @param string $column
21604: * @param array $values
21605: * @return \Illuminate\Database\Query\Builder
21606: * @static
21607: */
21608: public static function orWhereBetweenColumns($column, $values)
21609: {
21610: /** @var \Illuminate\Database\Query\Builder $instance */
21611: return $instance->orWhereBetweenColumns($column, $values);
21612: }
21613:
21614: /**
21615: * Add a where not between statement to the query.
21616: *
21617: * @param string $column
21618: * @param \Illuminate\Database\Query\iterable $values
21619: * @param string $boolean
21620: * @return \Illuminate\Database\Query\Builder
21621: * @static
21622: */
21623: public static function whereNotBetween($column, $values, $boolean = 'and')
21624: {
21625: /** @var \Illuminate\Database\Query\Builder $instance */
21626: return $instance->whereNotBetween($column, $values, $boolean);
21627: }
21628:
21629: /**
21630: * Add a where not between statement using columns to the query.
21631: *
21632: * @param string $column
21633: * @param array $values
21634: * @param string $boolean
21635: * @return \Illuminate\Database\Query\Builder
21636: * @static
21637: */
21638: public static function whereNotBetweenColumns($column, $values, $boolean = 'and')
21639: {
21640: /** @var \Illuminate\Database\Query\Builder $instance */
21641: return $instance->whereNotBetweenColumns($column, $values, $boolean);
21642: }
21643:
21644: /**
21645: * Add an or where not between statement to the query.
21646: *
21647: * @param string $column
21648: * @param \Illuminate\Database\Query\iterable $values
21649: * @return \Illuminate\Database\Query\Builder
21650: * @static
21651: */
21652: public static function orWhereNotBetween($column, $values)
21653: {
21654: /** @var \Illuminate\Database\Query\Builder $instance */
21655: return $instance->orWhereNotBetween($column, $values);
21656: }
21657:
21658: /**
21659: * Add an or where not between statement using columns to the query.
21660: *
21661: * @param string $column
21662: * @param array $values
21663: * @return \Illuminate\Database\Query\Builder
21664: * @static
21665: */
21666: public static function orWhereNotBetweenColumns($column, $values)
21667: {
21668: /** @var \Illuminate\Database\Query\Builder $instance */
21669: return $instance->orWhereNotBetweenColumns($column, $values);
21670: }
21671:
21672: /**
21673: * Add an "or where not null" clause to the query.
21674: *
21675: * @param string $column
21676: * @return \Illuminate\Database\Query\Builder
21677: * @static
21678: */
21679: public static function orWhereNotNull($column)
21680: {
21681: /** @var \Illuminate\Database\Query\Builder $instance */
21682: return $instance->orWhereNotNull($column);
21683: }
21684:
21685: /**
21686: * Add a "where date" statement to the query.
21687: *
21688: * @param string $column
21689: * @param string $operator
21690: * @param \DateTimeInterface|string|null $value
21691: * @param string $boolean
21692: * @return \Illuminate\Database\Query\Builder
21693: * @static
21694: */
21695: public static function whereDate($column, $operator, $value = null, $boolean = 'and')
21696: {
21697: /** @var \Illuminate\Database\Query\Builder $instance */
21698: return $instance->whereDate($column, $operator, $value, $boolean);
21699: }
21700:
21701: /**
21702: * Add an "or where date" statement to the query.
21703: *
21704: * @param string $column
21705: * @param string $operator
21706: * @param \DateTimeInterface|string|null $value
21707: * @return \Illuminate\Database\Query\Builder
21708: * @static
21709: */
21710: public static function orWhereDate($column, $operator, $value = null)
21711: {
21712: /** @var \Illuminate\Database\Query\Builder $instance */
21713: return $instance->orWhereDate($column, $operator, $value);
21714: }
21715:
21716: /**
21717: * Add a "where time" statement to the query.
21718: *
21719: * @param string $column
21720: * @param string $operator
21721: * @param \DateTimeInterface|string|null $value
21722: * @param string $boolean
21723: * @return \Illuminate\Database\Query\Builder
21724: * @static
21725: */
21726: public static function whereTime($column, $operator, $value = null, $boolean = 'and')
21727: {
21728: /** @var \Illuminate\Database\Query\Builder $instance */
21729: return $instance->whereTime($column, $operator, $value, $boolean);
21730: }
21731:
21732: /**
21733: * Add an "or where time" statement to the query.
21734: *
21735: * @param string $column
21736: * @param string $operator
21737: * @param \DateTimeInterface|string|null $value
21738: * @return \Illuminate\Database\Query\Builder
21739: * @static
21740: */
21741: public static function orWhereTime($column, $operator, $value = null)
21742: {
21743: /** @var \Illuminate\Database\Query\Builder $instance */
21744: return $instance->orWhereTime($column, $operator, $value);
21745: }
21746:
21747: /**
21748: * Add a "where day" statement to the query.
21749: *
21750: * @param string $column
21751: * @param string $operator
21752: * @param \DateTimeInterface|string|null $value
21753: * @param string $boolean
21754: * @return \Illuminate\Database\Query\Builder
21755: * @static
21756: */
21757: public static function whereDay($column, $operator, $value = null, $boolean = 'and')
21758: {
21759: /** @var \Illuminate\Database\Query\Builder $instance */
21760: return $instance->whereDay($column, $operator, $value, $boolean);
21761: }
21762:
21763: /**
21764: * Add an "or where day" statement to the query.
21765: *
21766: * @param string $column
21767: * @param string $operator
21768: * @param \DateTimeInterface|string|null $value
21769: * @return \Illuminate\Database\Query\Builder
21770: * @static
21771: */
21772: public static function orWhereDay($column, $operator, $value = null)
21773: {
21774: /** @var \Illuminate\Database\Query\Builder $instance */
21775: return $instance->orWhereDay($column, $operator, $value);
21776: }
21777:
21778: /**
21779: * Add a "where month" statement to the query.
21780: *
21781: * @param string $column
21782: * @param string $operator
21783: * @param \DateTimeInterface|string|null $value
21784: * @param string $boolean
21785: * @return \Illuminate\Database\Query\Builder
21786: * @static
21787: */
21788: public static function whereMonth($column, $operator, $value = null, $boolean = 'and')
21789: {
21790: /** @var \Illuminate\Database\Query\Builder $instance */
21791: return $instance->whereMonth($column, $operator, $value, $boolean);
21792: }
21793:
21794: /**
21795: * Add an "or where month" statement to the query.
21796: *
21797: * @param string $column
21798: * @param string $operator
21799: * @param \DateTimeInterface|string|null $value
21800: * @return \Illuminate\Database\Query\Builder
21801: * @static
21802: */
21803: public static function orWhereMonth($column, $operator, $value = null)
21804: {
21805: /** @var \Illuminate\Database\Query\Builder $instance */
21806: return $instance->orWhereMonth($column, $operator, $value);
21807: }
21808:
21809: /**
21810: * Add a "where year" statement to the query.
21811: *
21812: * @param string $column
21813: * @param string $operator
21814: * @param \DateTimeInterface|string|int|null $value
21815: * @param string $boolean
21816: * @return \Illuminate\Database\Query\Builder
21817: * @static
21818: */
21819: public static function whereYear($column, $operator, $value = null, $boolean = 'and')
21820: {
21821: /** @var \Illuminate\Database\Query\Builder $instance */
21822: return $instance->whereYear($column, $operator, $value, $boolean);
21823: }
21824:
21825: /**
21826: * Add an "or where year" statement to the query.
21827: *
21828: * @param string $column
21829: * @param string $operator
21830: * @param \DateTimeInterface|string|int|null $value
21831: * @return \Illuminate\Database\Query\Builder
21832: * @static
21833: */
21834: public static function orWhereYear($column, $operator, $value = null)
21835: {
21836: /** @var \Illuminate\Database\Query\Builder $instance */
21837: return $instance->orWhereYear($column, $operator, $value);
21838: }
21839:
21840: /**
21841: * Add a nested where statement to the query.
21842: *
21843: * @param \Closure $callback
21844: * @param string $boolean
21845: * @return \Illuminate\Database\Query\Builder
21846: * @static
21847: */
21848: public static function whereNested($callback, $boolean = 'and')
21849: {
21850: /** @var \Illuminate\Database\Query\Builder $instance */
21851: return $instance->whereNested($callback, $boolean);
21852: }
21853:
21854: /**
21855: * Create a new query instance for nested where condition.
21856: *
21857: * @return \Illuminate\Database\Query\Builder
21858: * @static
21859: */
21860: public static function forNestedWhere()
21861: {
21862: /** @var \Illuminate\Database\Query\Builder $instance */
21863: return $instance->forNestedWhere();
21864: }
21865:
21866: /**
21867: * Add another query builder as a nested where to the query builder.
21868: *
21869: * @param \Illuminate\Database\Query\Builder $query
21870: * @param string $boolean
21871: * @return \Illuminate\Database\Query\Builder
21872: * @static
21873: */
21874: public static function addNestedWhereQuery($query, $boolean = 'and')
21875: {
21876: /** @var \Illuminate\Database\Query\Builder $instance */
21877: return $instance->addNestedWhereQuery($query, $boolean);
21878: }
21879:
21880: /**
21881: * Add an exists clause to the query.
21882: *
21883: * @param \Closure $callback
21884: * @param string $boolean
21885: * @param bool $not
21886: * @return \Illuminate\Database\Query\Builder
21887: * @static
21888: */
21889: public static function whereExists($callback, $boolean = 'and', $not = false)
21890: {
21891: /** @var \Illuminate\Database\Query\Builder $instance */
21892: return $instance->whereExists($callback, $boolean, $not);
21893: }
21894:
21895: /**
21896: * Add an or exists clause to the query.
21897: *
21898: * @param \Closure $callback
21899: * @param bool $not
21900: * @return \Illuminate\Database\Query\Builder
21901: * @static
21902: */
21903: public static function orWhereExists($callback, $not = false)
21904: {
21905: /** @var \Illuminate\Database\Query\Builder $instance */
21906: return $instance->orWhereExists($callback, $not);
21907: }
21908:
21909: /**
21910: * Add a where not exists clause to the query.
21911: *
21912: * @param \Closure $callback
21913: * @param string $boolean
21914: * @return \Illuminate\Database\Query\Builder
21915: * @static
21916: */
21917: public static function whereNotExists($callback, $boolean = 'and')
21918: {
21919: /** @var \Illuminate\Database\Query\Builder $instance */
21920: return $instance->whereNotExists($callback, $boolean);
21921: }
21922:
21923: /**
21924: * Add a where not exists clause to the query.
21925: *
21926: * @param \Closure $callback
21927: * @return \Illuminate\Database\Query\Builder
21928: * @static
21929: */
21930: public static function orWhereNotExists($callback)
21931: {
21932: /** @var \Illuminate\Database\Query\Builder $instance */
21933: return $instance->orWhereNotExists($callback);
21934: }
21935:
21936: /**
21937: * Add an exists clause to the query.
21938: *
21939: * @param \Illuminate\Database\Query\Builder $query
21940: * @param string $boolean
21941: * @param bool $not
21942: * @return \Illuminate\Database\Query\Builder
21943: * @static
21944: */
21945: public static function addWhereExistsQuery($query, $boolean = 'and', $not = false)
21946: {
21947: /** @var \Illuminate\Database\Query\Builder $instance */
21948: return $instance->addWhereExistsQuery($query, $boolean, $not);
21949: }
21950:
21951: /**
21952: * Adds a where condition using row values.
21953: *
21954: * @param array $columns
21955: * @param string $operator
21956: * @param array $values
21957: * @param string $boolean
21958: * @return \Illuminate\Database\Query\Builder
21959: * @throws \InvalidArgumentException
21960: * @static
21961: */
21962: public static function whereRowValues($columns, $operator, $values, $boolean = 'and')
21963: {
21964: /** @var \Illuminate\Database\Query\Builder $instance */
21965: return $instance->whereRowValues($columns, $operator, $values, $boolean);
21966: }
21967:
21968: /**
21969: * Adds an or where condition using row values.
21970: *
21971: * @param array $columns
21972: * @param string $operator
21973: * @param array $values
21974: * @return \Illuminate\Database\Query\Builder
21975: * @static
21976: */
21977: public static function orWhereRowValues($columns, $operator, $values)
21978: {
21979: /** @var \Illuminate\Database\Query\Builder $instance */
21980: return $instance->orWhereRowValues($columns, $operator, $values);
21981: }
21982:
21983: /**
21984: * Add a "where JSON contains" clause to the query.
21985: *
21986: * @param string $column
21987: * @param mixed $value
21988: * @param string $boolean
21989: * @param bool $not
21990: * @return \Illuminate\Database\Query\Builder
21991: * @static
21992: */
21993: public static function whereJsonContains($column, $value, $boolean = 'and', $not = false)
21994: {
21995: /** @var \Illuminate\Database\Query\Builder $instance */
21996: return $instance->whereJsonContains($column, $value, $boolean, $not);
21997: }
21998:
21999: /**
22000: * Add an "or where JSON contains" clause to the query.
22001: *
22002: * @param string $column
22003: * @param mixed $value
22004: * @return \Illuminate\Database\Query\Builder
22005: * @static
22006: */
22007: public static function orWhereJsonContains($column, $value)
22008: {
22009: /** @var \Illuminate\Database\Query\Builder $instance */
22010: return $instance->orWhereJsonContains($column, $value);
22011: }
22012:
22013: /**
22014: * Add a "where JSON not contains" clause to the query.
22015: *
22016: * @param string $column
22017: * @param mixed $value
22018: * @param string $boolean
22019: * @return \Illuminate\Database\Query\Builder
22020: * @static
22021: */
22022: public static function whereJsonDoesntContain($column, $value, $boolean = 'and')
22023: {
22024: /** @var \Illuminate\Database\Query\Builder $instance */
22025: return $instance->whereJsonDoesntContain($column, $value, $boolean);
22026: }
22027:
22028: /**
22029: * Add an "or where JSON not contains" clause to the query.
22030: *
22031: * @param string $column
22032: * @param mixed $value
22033: * @return \Illuminate\Database\Query\Builder
22034: * @static
22035: */
22036: public static function orWhereJsonDoesntContain($column, $value)
22037: {
22038: /** @var \Illuminate\Database\Query\Builder $instance */
22039: return $instance->orWhereJsonDoesntContain($column, $value);
22040: }
22041:
22042: /**
22043: * Add a clause that determines if a JSON path exists to the query.
22044: *
22045: * @param string $column
22046: * @param string $boolean
22047: * @param bool $not
22048: * @return \Illuminate\Database\Query\Builder
22049: * @static
22050: */
22051: public static function whereJsonContainsKey($column, $boolean = 'and', $not = false)
22052: {
22053: /** @var \Illuminate\Database\Query\Builder $instance */
22054: return $instance->whereJsonContainsKey($column, $boolean, $not);
22055: }
22056:
22057: /**
22058: * Add an "or" clause that determines if a JSON path exists to the query.
22059: *
22060: * @param string $column
22061: * @return \Illuminate\Database\Query\Builder
22062: * @static
22063: */
22064: public static function orWhereJsonContainsKey($column)
22065: {
22066: /** @var \Illuminate\Database\Query\Builder $instance */
22067: return $instance->orWhereJsonContainsKey($column);
22068: }
22069:
22070: /**
22071: * Add a clause that determines if a JSON path does not exist to the query.
22072: *
22073: * @param string $column
22074: * @param string $boolean
22075: * @return \Illuminate\Database\Query\Builder
22076: * @static
22077: */
22078: public static function whereJsonDoesntContainKey($column, $boolean = 'and')
22079: {
22080: /** @var \Illuminate\Database\Query\Builder $instance */
22081: return $instance->whereJsonDoesntContainKey($column, $boolean);
22082: }
22083:
22084: /**
22085: * Add an "or" clause that determines if a JSON path does not exist to the query.
22086: *
22087: * @param string $column
22088: * @return \Illuminate\Database\Query\Builder
22089: * @static
22090: */
22091: public static function orWhereJsonDoesntContainKey($column)
22092: {
22093: /** @var \Illuminate\Database\Query\Builder $instance */
22094: return $instance->orWhereJsonDoesntContainKey($column);
22095: }
22096:
22097: /**
22098: * Add a "where JSON length" clause to the query.
22099: *
22100: * @param string $column
22101: * @param mixed $operator
22102: * @param mixed $value
22103: * @param string $boolean
22104: * @return \Illuminate\Database\Query\Builder
22105: * @static
22106: */
22107: public static function whereJsonLength($column, $operator, $value = null, $boolean = 'and')
22108: {
22109: /** @var \Illuminate\Database\Query\Builder $instance */
22110: return $instance->whereJsonLength($column, $operator, $value, $boolean);
22111: }
22112:
22113: /**
22114: * Add an "or where JSON length" clause to the query.
22115: *
22116: * @param string $column
22117: * @param mixed $operator
22118: * @param mixed $value
22119: * @return \Illuminate\Database\Query\Builder
22120: * @static
22121: */
22122: public static function orWhereJsonLength($column, $operator, $value = null)
22123: {
22124: /** @var \Illuminate\Database\Query\Builder $instance */
22125: return $instance->orWhereJsonLength($column, $operator, $value);
22126: }
22127:
22128: /**
22129: * Handles dynamic "where" clauses to the query.
22130: *
22131: * @param string $method
22132: * @param array $parameters
22133: * @return \Illuminate\Database\Query\Builder
22134: * @static
22135: */
22136: public static function dynamicWhere($method, $parameters)
22137: {
22138: /** @var \Illuminate\Database\Query\Builder $instance */
22139: return $instance->dynamicWhere($method, $parameters);
22140: }
22141:
22142: /**
22143: * Add a "where fulltext" clause to the query.
22144: *
22145: * @param string|string[] $columns
22146: * @param string $value
22147: * @param string $boolean
22148: * @return \Illuminate\Database\Query\Builder
22149: * @static
22150: */
22151: public static function whereFullText($columns, $value, $options = [], $boolean = 'and')
22152: {
22153: /** @var \Illuminate\Database\Query\Builder $instance */
22154: return $instance->whereFullText($columns, $value, $options, $boolean);
22155: }
22156:
22157: /**
22158: * Add a "or where fulltext" clause to the query.
22159: *
22160: * @param string|string[] $columns
22161: * @param string $value
22162: * @return \Illuminate\Database\Query\Builder
22163: * @static
22164: */
22165: public static function orWhereFullText($columns, $value, $options = [])
22166: {
22167: /** @var \Illuminate\Database\Query\Builder $instance */
22168: return $instance->orWhereFullText($columns, $value, $options);
22169: }
22170:
22171: /**
22172: * Add a "group by" clause to the query.
22173: *
22174: * @param array|string $groups
22175: * @return \Illuminate\Database\Query\Builder
22176: * @static
22177: */
22178: public static function groupBy(...$groups)
22179: {
22180: /** @var \Illuminate\Database\Query\Builder $instance */
22181: return $instance->groupBy(...$groups);
22182: }
22183:
22184: /**
22185: * Add a raw groupBy clause to the query.
22186: *
22187: * @param string $sql
22188: * @param array $bindings
22189: * @return \Illuminate\Database\Query\Builder
22190: * @static
22191: */
22192: public static function groupByRaw($sql, $bindings = [])
22193: {
22194: /** @var \Illuminate\Database\Query\Builder $instance */
22195: return $instance->groupByRaw($sql, $bindings);
22196: }
22197:
22198: /**
22199: * Add a "having" clause to the query.
22200: *
22201: * @param \Closure|string $column
22202: * @param string|int|float|null $operator
22203: * @param string|int|float|null $value
22204: * @param string $boolean
22205: * @return \Illuminate\Database\Query\Builder
22206: * @static
22207: */
22208: public static function having($column, $operator = null, $value = null, $boolean = 'and')
22209: {
22210: /** @var \Illuminate\Database\Query\Builder $instance */
22211: return $instance->having($column, $operator, $value, $boolean);
22212: }
22213:
22214: /**
22215: * Add an "or having" clause to the query.
22216: *
22217: * @param \Closure|string $column
22218: * @param string|int|float|null $operator
22219: * @param string|int|float|null $value
22220: * @return \Illuminate\Database\Query\Builder
22221: * @static
22222: */
22223: public static function orHaving($column, $operator = null, $value = null)
22224: {
22225: /** @var \Illuminate\Database\Query\Builder $instance */
22226: return $instance->orHaving($column, $operator, $value);
22227: }
22228:
22229: /**
22230: * Add a nested having statement to the query.
22231: *
22232: * @param \Closure $callback
22233: * @param string $boolean
22234: * @return \Illuminate\Database\Query\Builder
22235: * @static
22236: */
22237: public static function havingNested($callback, $boolean = 'and')
22238: {
22239: /** @var \Illuminate\Database\Query\Builder $instance */
22240: return $instance->havingNested($callback, $boolean);
22241: }
22242:
22243: /**
22244: * Add another query builder as a nested having to the query builder.
22245: *
22246: * @param \Illuminate\Database\Query\Builder $query
22247: * @param string $boolean
22248: * @return \Illuminate\Database\Query\Builder
22249: * @static
22250: */
22251: public static function addNestedHavingQuery($query, $boolean = 'and')
22252: {
22253: /** @var \Illuminate\Database\Query\Builder $instance */
22254: return $instance->addNestedHavingQuery($query, $boolean);
22255: }
22256:
22257: /**
22258: * Add a "having null" clause to the query.
22259: *
22260: * @param string|array $columns
22261: * @param string $boolean
22262: * @param bool $not
22263: * @return \Illuminate\Database\Query\Builder
22264: * @static
22265: */
22266: public static function havingNull($columns, $boolean = 'and', $not = false)
22267: {
22268: /** @var \Illuminate\Database\Query\Builder $instance */
22269: return $instance->havingNull($columns, $boolean, $not);
22270: }
22271:
22272: /**
22273: * Add an "or having null" clause to the query.
22274: *
22275: * @param string $column
22276: * @return \Illuminate\Database\Query\Builder
22277: * @static
22278: */
22279: public static function orHavingNull($column)
22280: {
22281: /** @var \Illuminate\Database\Query\Builder $instance */
22282: return $instance->orHavingNull($column);
22283: }
22284:
22285: /**
22286: * Add a "having not null" clause to the query.
22287: *
22288: * @param string|array $columns
22289: * @param string $boolean
22290: * @return \Illuminate\Database\Query\Builder
22291: * @static
22292: */
22293: public static function havingNotNull($columns, $boolean = 'and')
22294: {
22295: /** @var \Illuminate\Database\Query\Builder $instance */
22296: return $instance->havingNotNull($columns, $boolean);
22297: }
22298:
22299: /**
22300: * Add an "or having not null" clause to the query.
22301: *
22302: * @param string $column
22303: * @return \Illuminate\Database\Query\Builder
22304: * @static
22305: */
22306: public static function orHavingNotNull($column)
22307: {
22308: /** @var \Illuminate\Database\Query\Builder $instance */
22309: return $instance->orHavingNotNull($column);
22310: }
22311:
22312: /**
22313: * Add a "having between " clause to the query.
22314: *
22315: * @param string $column
22316: * @param array $values
22317: * @param string $boolean
22318: * @param bool $not
22319: * @return \Illuminate\Database\Query\Builder
22320: * @static
22321: */
22322: public static function havingBetween($column, $values, $boolean = 'and', $not = false)
22323: {
22324: /** @var \Illuminate\Database\Query\Builder $instance */
22325: return $instance->havingBetween($column, $values, $boolean, $not);
22326: }
22327:
22328: /**
22329: * Add a raw having clause to the query.
22330: *
22331: * @param string $sql
22332: * @param array $bindings
22333: * @param string $boolean
22334: * @return \Illuminate\Database\Query\Builder
22335: * @static
22336: */
22337: public static function havingRaw($sql, $bindings = [], $boolean = 'and')
22338: {
22339: /** @var \Illuminate\Database\Query\Builder $instance */
22340: return $instance->havingRaw($sql, $bindings, $boolean);
22341: }
22342:
22343: /**
22344: * Add a raw or having clause to the query.
22345: *
22346: * @param string $sql
22347: * @param array $bindings
22348: * @return \Illuminate\Database\Query\Builder
22349: * @static
22350: */
22351: public static function orHavingRaw($sql, $bindings = [])
22352: {
22353: /** @var \Illuminate\Database\Query\Builder $instance */
22354: return $instance->orHavingRaw($sql, $bindings);
22355: }
22356:
22357: /**
22358: * Add an "order by" clause to the query.
22359: *
22360: * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column
22361: * @param string $direction
22362: * @return \Illuminate\Database\Query\Builder
22363: * @throws \InvalidArgumentException
22364: * @static
22365: */
22366: public static function orderBy($column, $direction = 'asc')
22367: {
22368: /** @var \Illuminate\Database\Query\Builder $instance */
22369: return $instance->orderBy($column, $direction);
22370: }
22371:
22372: /**
22373: * Add a descending "order by" clause to the query.
22374: *
22375: * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Expression|string $column
22376: * @return \Illuminate\Database\Query\Builder
22377: * @static
22378: */
22379: public static function orderByDesc($column)
22380: {
22381: /** @var \Illuminate\Database\Query\Builder $instance */
22382: return $instance->orderByDesc($column);
22383: }
22384:
22385: /**
22386: * Put the query's results in random order.
22387: *
22388: * @param string $seed
22389: * @return \Illuminate\Database\Query\Builder
22390: * @static
22391: */
22392: public static function inRandomOrder($seed = '')
22393: {
22394: /** @var \Illuminate\Database\Query\Builder $instance */
22395: return $instance->inRandomOrder($seed);
22396: }
22397:
22398: /**
22399: * Add a raw "order by" clause to the query.
22400: *
22401: * @param string $sql
22402: * @param array $bindings
22403: * @return \Illuminate\Database\Query\Builder
22404: * @static
22405: */
22406: public static function orderByRaw($sql, $bindings = [])
22407: {
22408: /** @var \Illuminate\Database\Query\Builder $instance */
22409: return $instance->orderByRaw($sql, $bindings);
22410: }
22411:
22412: /**
22413: * Alias to set the "offset" value of the query.
22414: *
22415: * @param int $value
22416: * @return \Illuminate\Database\Query\Builder
22417: * @static
22418: */
22419: public static function skip($value)
22420: {
22421: /** @var \Illuminate\Database\Query\Builder $instance */
22422: return $instance->skip($value);
22423: }
22424:
22425: /**
22426: * Set the "offset" value of the query.
22427: *
22428: * @param int $value
22429: * @return \Illuminate\Database\Query\Builder
22430: * @static
22431: */
22432: public static function offset($value)
22433: {
22434: /** @var \Illuminate\Database\Query\Builder $instance */
22435: return $instance->offset($value);
22436: }
22437:
22438: /**
22439: * Alias to set the "limit" value of the query.
22440: *
22441: * @param int $value
22442: * @return \Illuminate\Database\Query\Builder
22443: * @static
22444: */
22445: public static function take($value)
22446: {
22447: /** @var \Illuminate\Database\Query\Builder $instance */
22448: return $instance->take($value);
22449: }
22450:
22451: /**
22452: * Set the "limit" value of the query.
22453: *
22454: * @param int $value
22455: * @return \Illuminate\Database\Query\Builder
22456: * @static
22457: */
22458: public static function limit($value)
22459: {
22460: /** @var \Illuminate\Database\Query\Builder $instance */
22461: return $instance->limit($value);
22462: }
22463:
22464: /**
22465: * Set the limit and offset for a given page.
22466: *
22467: * @param int $page
22468: * @param int $perPage
22469: * @return \Illuminate\Database\Query\Builder
22470: * @static
22471: */
22472: public static function forPage($page, $perPage = 15)
22473: {
22474: /** @var \Illuminate\Database\Query\Builder $instance */
22475: return $instance->forPage($page, $perPage);
22476: }
22477:
22478: /**
22479: * Constrain the query to the previous "page" of results before a given ID.
22480: *
22481: * @param int $perPage
22482: * @param int|null $lastId
22483: * @param string $column
22484: * @return \Illuminate\Database\Query\Builder
22485: * @static
22486: */
22487: public static function forPageBeforeId($perPage = 15, $lastId = 0, $column = 'id')
22488: {
22489: /** @var \Illuminate\Database\Query\Builder $instance */
22490: return $instance->forPageBeforeId($perPage, $lastId, $column);
22491: }
22492:
22493: /**
22494: * Constrain the query to the next "page" of results after a given ID.
22495: *
22496: * @param int $perPage
22497: * @param int|null $lastId
22498: * @param string $column
22499: * @return \Illuminate\Database\Query\Builder
22500: * @static
22501: */
22502: public static function forPageAfterId($perPage = 15, $lastId = 0, $column = 'id')
22503: {
22504: /** @var \Illuminate\Database\Query\Builder $instance */
22505: return $instance->forPageAfterId($perPage, $lastId, $column);
22506: }
22507:
22508: /**
22509: * Remove all existing orders and optionally add a new order.
22510: *
22511: * @param \Closure|\Illuminate\Database\Query\Builder|\Illuminate\Database\Query\Expression|string|null $column
22512: * @param string $direction
22513: * @return \Illuminate\Database\Query\Builder
22514: * @static
22515: */
22516: public static function reorder($column = null, $direction = 'asc')
22517: {
22518: /** @var \Illuminate\Database\Query\Builder $instance */
22519: return $instance->reorder($column, $direction);
22520: }
22521:
22522: /**
22523: * Add a union statement to the query.
22524: *
22525: * @param \Illuminate\Database\Query\Builder|\Closure $query
22526: * @param bool $all
22527: * @return \Illuminate\Database\Query\Builder
22528: * @static
22529: */
22530: public static function union($query, $all = false)
22531: {
22532: /** @var \Illuminate\Database\Query\Builder $instance */
22533: return $instance->union($query, $all);
22534: }
22535:
22536: /**
22537: * Add a union all statement to the query.
22538: *
22539: * @param \Illuminate\Database\Query\Builder|\Closure $query
22540: * @return \Illuminate\Database\Query\Builder
22541: * @static
22542: */
22543: public static function unionAll($query)
22544: {
22545: /** @var \Illuminate\Database\Query\Builder $instance */
22546: return $instance->unionAll($query);
22547: }
22548:
22549: /**
22550: * Lock the selected rows in the table.
22551: *
22552: * @param string|bool $value
22553: * @return \Illuminate\Database\Query\Builder
22554: * @static
22555: */
22556: public static function lock($value = true)
22557: {
22558: /** @var \Illuminate\Database\Query\Builder $instance */
22559: return $instance->lock($value);
22560: }
22561:
22562: /**
22563: * Lock the selected rows in the table for updating.
22564: *
22565: * @return \Illuminate\Database\Query\Builder
22566: * @static
22567: */
22568: public static function lockForUpdate()
22569: {
22570: /** @var \Illuminate\Database\Query\Builder $instance */
22571: return $instance->lockForUpdate();
22572: }
22573:
22574: /**
22575: * Share lock the selected rows in the table.
22576: *
22577: * @return \Illuminate\Database\Query\Builder
22578: * @static
22579: */
22580: public static function sharedLock()
22581: {
22582: /** @var \Illuminate\Database\Query\Builder $instance */
22583: return $instance->sharedLock();
22584: }
22585:
22586: /**
22587: * Register a closure to be invoked before the query is executed.
22588: *
22589: * @param callable $callback
22590: * @return \Illuminate\Database\Query\Builder
22591: * @static
22592: */
22593: public static function beforeQuery($callback)
22594: {
22595: /** @var \Illuminate\Database\Query\Builder $instance */
22596: return $instance->beforeQuery($callback);
22597: }
22598:
22599: /**
22600: * Invoke the "before query" modification callbacks.
22601: *
22602: * @return void
22603: * @static
22604: */
22605: public static function applyBeforeQueryCallbacks()
22606: {
22607: /** @var \Illuminate\Database\Query\Builder $instance */
22608: $instance->applyBeforeQueryCallbacks();
22609: }
22610:
22611: /**
22612: * Get the SQL representation of the query.
22613: *
22614: * @return string
22615: * @static
22616: */
22617: public static function toSql()
22618: {
22619: /** @var \Illuminate\Database\Query\Builder $instance */
22620: return $instance->toSql();
22621: }
22622:
22623: /**
22624: * Get the count of the total records for the paginator.
22625: *
22626: * @param array $columns
22627: * @return int
22628: * @static
22629: */
22630: public static function getCountForPagination($columns = [])
22631: {
22632: /** @var \Illuminate\Database\Query\Builder $instance */
22633: return $instance->getCountForPagination($columns);
22634: }
22635:
22636: /**
22637: * Concatenate values of a given column as a string.
22638: *
22639: * @param string $column
22640: * @param string $glue
22641: * @return string
22642: * @static
22643: */
22644: public static function implode($column, $glue = '')
22645: {
22646: /** @var \Illuminate\Database\Query\Builder $instance */
22647: return $instance->implode($column, $glue);
22648: }
22649:
22650: /**
22651: * Determine if any rows exist for the current query.
22652: *
22653: * @return bool
22654: * @static
22655: */
22656: public static function exists()
22657: {
22658: /** @var \Illuminate\Database\Query\Builder $instance */
22659: return $instance->exists();
22660: }
22661:
22662: /**
22663: * Determine if no rows exist for the current query.
22664: *
22665: * @return bool
22666: * @static
22667: */
22668: public static function doesntExist()
22669: {
22670: /** @var \Illuminate\Database\Query\Builder $instance */
22671: return $instance->doesntExist();
22672: }
22673:
22674: /**
22675: * Execute the given callback if no rows exist for the current query.
22676: *
22677: * @param \Closure $callback
22678: * @return mixed
22679: * @static
22680: */
22681: public static function existsOr($callback)
22682: {
22683: /** @var \Illuminate\Database\Query\Builder $instance */
22684: return $instance->existsOr($callback);
22685: }
22686:
22687: /**
22688: * Execute the given callback if rows exist for the current query.
22689: *
22690: * @param \Closure $callback
22691: * @return mixed
22692: * @static
22693: */
22694: public static function doesntExistOr($callback)
22695: {
22696: /** @var \Illuminate\Database\Query\Builder $instance */
22697: return $instance->doesntExistOr($callback);
22698: }
22699:
22700: /**
22701: * Retrieve the "count" result of the query.
22702: *
22703: * @param string $columns
22704: * @return int
22705: * @static
22706: */
22707: public static function count($columns = '*')
22708: {
22709: /** @var \Illuminate\Database\Query\Builder $instance */
22710: return $instance->count($columns);
22711: }
22712:
22713: /**
22714: * Retrieve the minimum value of a given column.
22715: *
22716: * @param string $column
22717: * @return mixed
22718: * @static
22719: */
22720: public static function min($column)
22721: {
22722: /** @var \Illuminate\Database\Query\Builder $instance */
22723: return $instance->min($column);
22724: }
22725:
22726: /**
22727: * Retrieve the maximum value of a given column.
22728: *
22729: * @param string $column
22730: * @return mixed
22731: * @static
22732: */
22733: public static function max($column)
22734: {
22735: /** @var \Illuminate\Database\Query\Builder $instance */
22736: return $instance->max($column);
22737: }
22738:
22739: /**
22740: * Retrieve the sum of the values of a given column.
22741: *
22742: * @param string $column
22743: * @return mixed
22744: * @static
22745: */
22746: public static function sum($column)
22747: {
22748: /** @var \Illuminate\Database\Query\Builder $instance */
22749: return $instance->sum($column);
22750: }
22751:
22752: /**
22753: * Retrieve the average of the values of a given column.
22754: *
22755: * @param string $column
22756: * @return mixed
22757: * @static
22758: */
22759: public static function avg($column)
22760: {
22761: /** @var \Illuminate\Database\Query\Builder $instance */
22762: return $instance->avg($column);
22763: }
22764:
22765: /**
22766: * Alias for the "avg" method.
22767: *
22768: * @param string $column
22769: * @return mixed
22770: * @static
22771: */
22772: public static function average($column)
22773: {
22774: /** @var \Illuminate\Database\Query\Builder $instance */
22775: return $instance->average($column);
22776: }
22777:
22778: /**
22779: * Execute an aggregate function on the database.
22780: *
22781: * @param string $function
22782: * @param array $columns
22783: * @return mixed
22784: * @static
22785: */
22786: public static function aggregate($function, $columns = [])
22787: {
22788: /** @var \Illuminate\Database\Query\Builder $instance */
22789: return $instance->aggregate($function, $columns);
22790: }
22791:
22792: /**
22793: * Execute a numeric aggregate function on the database.
22794: *
22795: * @param string $function
22796: * @param array $columns
22797: * @return float|int
22798: * @static
22799: */
22800: public static function numericAggregate($function, $columns = [])
22801: {
22802: /** @var \Illuminate\Database\Query\Builder $instance */
22803: return $instance->numericAggregate($function, $columns);
22804: }
22805:
22806: /**
22807: * Insert new records into the database.
22808: *
22809: * @param array $values
22810: * @return bool
22811: * @static
22812: */
22813: public static function insert($values)
22814: {
22815: /** @var \Illuminate\Database\Query\Builder $instance */
22816: return $instance->insert($values);
22817: }
22818:
22819: /**
22820: * Insert new records into the database while ignoring errors.
22821: *
22822: * @param array $values
22823: * @return int
22824: * @static
22825: */
22826: public static function insertOrIgnore($values)
22827: {
22828: /** @var \Illuminate\Database\Query\Builder $instance */
22829: return $instance->insertOrIgnore($values);
22830: }
22831:
22832: /**
22833: * Insert a new record and get the value of the primary key.
22834: *
22835: * @param array $values
22836: * @param string|null $sequence
22837: * @return int
22838: * @static
22839: */
22840: public static function insertGetId($values, $sequence = null)
22841: {
22842: /** @var \Illuminate\Database\Query\Builder $instance */
22843: return $instance->insertGetId($values, $sequence);
22844: }
22845:
22846: /**
22847: * Insert new records into the table using a subquery.
22848: *
22849: * @param array $columns
22850: * @param \Closure|\Illuminate\Database\Query\Builder|string $query
22851: * @return int
22852: * @static
22853: */
22854: public static function insertUsing($columns, $query)
22855: {
22856: /** @var \Illuminate\Database\Query\Builder $instance */
22857: return $instance->insertUsing($columns, $query);
22858: }
22859:
22860: /**
22861: * Update records in a PostgreSQL database using the update from syntax.
22862: *
22863: * @param array $values
22864: * @return int
22865: * @static
22866: */
22867: public static function updateFrom($values)
22868: {
22869: /** @var \Illuminate\Database\Query\Builder $instance */
22870: return $instance->updateFrom($values);
22871: }
22872:
22873: /**
22874: * Insert or update a record matching the attributes, and fill it with values.
22875: *
22876: * @param array $attributes
22877: * @param array $values
22878: * @return bool
22879: * @static
22880: */
22881: public static function updateOrInsert($attributes, $values = [])
22882: {
22883: /** @var \Illuminate\Database\Query\Builder $instance */
22884: return $instance->updateOrInsert($attributes, $values);
22885: }
22886:
22887: /**
22888: * Run a truncate statement on the table.
22889: *
22890: * @return void
22891: * @static
22892: */
22893: public static function truncate()
22894: {
22895: /** @var \Illuminate\Database\Query\Builder $instance */
22896: $instance->truncate();
22897: }
22898:
22899: /**
22900: * Create a raw database expression.
22901: *
22902: * @param mixed $value
22903: * @return \Illuminate\Database\Query\Expression
22904: * @static
22905: */
22906: public static function raw($value)
22907: {
22908: /** @var \Illuminate\Database\Query\Builder $instance */
22909: return $instance->raw($value);
22910: }
22911:
22912: /**
22913: * Get the current query value bindings in a flattened array.
22914: *
22915: * @return array
22916: * @static
22917: */
22918: public static function getBindings()
22919: {
22920: /** @var \Illuminate\Database\Query\Builder $instance */
22921: return $instance->getBindings();
22922: }
22923:
22924: /**
22925: * Get the raw array of bindings.
22926: *
22927: * @return array
22928: * @static
22929: */
22930: public static function getRawBindings()
22931: {
22932: /** @var \Illuminate\Database\Query\Builder $instance */
22933: return $instance->getRawBindings();
22934: }
22935:
22936: /**
22937: * Set the bindings on the query builder.
22938: *
22939: * @param array $bindings
22940: * @param string $type
22941: * @return \Illuminate\Database\Query\Builder
22942: * @throws \InvalidArgumentException
22943: * @static
22944: */
22945: public static function setBindings($bindings, $type = 'where')
22946: {
22947: /** @var \Illuminate\Database\Query\Builder $instance */
22948: return $instance->setBindings($bindings, $type);
22949: }
22950:
22951: /**
22952: * Add a binding to the query.
22953: *
22954: * @param mixed $value
22955: * @param string $type
22956: * @return \Illuminate\Database\Query\Builder
22957: * @throws \InvalidArgumentException
22958: * @static
22959: */
22960: public static function addBinding($value, $type = 'where')
22961: {
22962: /** @var \Illuminate\Database\Query\Builder $instance */
22963: return $instance->addBinding($value, $type);
22964: }
22965:
22966: /**
22967: * Cast the given binding value.
22968: *
22969: * @param mixed $value
22970: * @return mixed
22971: * @static
22972: */
22973: public static function castBinding($value)
22974: {
22975: /** @var \Illuminate\Database\Query\Builder $instance */
22976: return $instance->castBinding($value);
22977: }
22978:
22979: /**
22980: * Merge an array of bindings into our bindings.
22981: *
22982: * @param \Illuminate\Database\Query\Builder $query
22983: * @return \Illuminate\Database\Query\Builder
22984: * @static
22985: */
22986: public static function mergeBindings($query)
22987: {
22988: /** @var \Illuminate\Database\Query\Builder $instance */
22989: return $instance->mergeBindings($query);
22990: }
22991:
22992: /**
22993: * Remove all of the expressions from a list of bindings.
22994: *
22995: * @param array $bindings
22996: * @return array
22997: * @static
22998: */
22999: public static function cleanBindings($bindings)
23000: {
23001: /** @var \Illuminate\Database\Query\Builder $instance */
23002: return $instance->cleanBindings($bindings);
23003: }
23004:
23005: /**
23006: * Get the database query processor instance.
23007: *
23008: * @return \Illuminate\Database\Query\Processors\Processor
23009: * @static
23010: */
23011: public static function getProcessor()
23012: {
23013: /** @var \Illuminate\Database\Query\Builder $instance */
23014: return $instance->getProcessor();
23015: }
23016:
23017: /**
23018: * Get the query grammar instance.
23019: *
23020: * @return \Illuminate\Database\Query\Grammars\Grammar
23021: * @static
23022: */
23023: public static function getGrammar()
23024: {
23025: /** @var \Illuminate\Database\Query\Builder $instance */
23026: return $instance->getGrammar();
23027: }
23028:
23029: /**
23030: * Use the "write" PDO connection when executing the query.
23031: *
23032: * @return \Illuminate\Database\Query\Builder
23033: * @static
23034: */
23035: public static function useWritePdo()
23036: {
23037: /** @var \Illuminate\Database\Query\Builder $instance */
23038: return $instance->useWritePdo();
23039: }
23040:
23041: /**
23042: * Clone the query without the given properties.
23043: *
23044: * @param array $properties
23045: * @return static
23046: * @static
23047: */
23048: public static function cloneWithout($properties)
23049: {
23050: /** @var \Illuminate\Database\Query\Builder $instance */
23051: return $instance->cloneWithout($properties);
23052: }
23053:
23054: /**
23055: * Clone the query without the given bindings.
23056: *
23057: * @param array $except
23058: * @return static
23059: * @static
23060: */
23061: public static function cloneWithoutBindings($except)
23062: {
23063: /** @var \Illuminate\Database\Query\Builder $instance */
23064: return $instance->cloneWithoutBindings($except);
23065: }
23066:
23067: /**
23068: * Dump the current SQL and bindings.
23069: *
23070: * @return \Illuminate\Database\Query\Builder
23071: * @static
23072: */
23073: public static function dump()
23074: {
23075: /** @var \Illuminate\Database\Query\Builder $instance */
23076: return $instance->dump();
23077: }
23078:
23079: /**
23080: * Die and dump the current SQL and bindings.
23081: *
23082: * @return \Illuminate\Database\Query\never
23083: * @static
23084: */
23085: public static function dd()
23086: {
23087: /** @var \Illuminate\Database\Query\Builder $instance */
23088: return $instance->dd();
23089: }
23090:
23091: /**
23092: * Explains the query.
23093: *
23094: * @return \Illuminate\Support\Collection
23095: * @static
23096: */
23097: public static function explain()
23098: {
23099: /** @var \Illuminate\Database\Query\Builder $instance */
23100: return $instance->explain();
23101: }
23102:
23103: /**
23104: * Register a custom macro.
23105: *
23106: * @param string $name
23107: * @param object|callable $macro
23108: * @return void
23109: * @static
23110: */
23111: public static function macro($name, $macro)
23112: {
23113: \Illuminate\Database\Query\Builder::macro($name, $macro);
23114: }
23115:
23116: /**
23117: * Mix another object into the class.
23118: *
23119: * @param object $mixin
23120: * @param bool $replace
23121: * @return void
23122: * @throws \ReflectionException
23123: * @static
23124: */
23125: public static function mixin($mixin, $replace = true)
23126: {
23127: \Illuminate\Database\Query\Builder::mixin($mixin, $replace);
23128: }
23129:
23130: /**
23131: * Flush the existing macros.
23132: *
23133: * @return void
23134: * @static
23135: */
23136: public static function flushMacros()
23137: {
23138: \Illuminate\Database\Query\Builder::flushMacros();
23139: }
23140:
23141: /**
23142: * Dynamically handle calls to the class.
23143: *
23144: * @param string $method
23145: * @param array $parameters
23146: * @return mixed
23147: * @throws \BadMethodCallException
23148: * @static
23149: */
23150: public static function macroCall($method, $parameters)
23151: {
23152: /** @var \Illuminate\Database\Query\Builder $instance */
23153: return $instance->macroCall($method, $parameters);
23154: }
23155:
23156: /**
23157: *
23158: *
23159: * @see \Spatie\LaravelRay\RayServiceProvider::registerMacros()
23160: * @static
23161: */
23162: public static function ray()
23163: {
23164: return \Illuminate\Database\Query\Builder::ray();
23165: }
23166: }
23167: class Event extends \Illuminate\Support\Facades\Event {}
23168: class File extends \Illuminate\Support\Facades\File {}
23169: class Gate extends \Illuminate\Support\Facades\Gate {}
23170: class Hash extends \Illuminate\Support\Facades\Hash {}
23171: class Http extends \Illuminate\Support\Facades\Http {}
23172: class Lang extends \Illuminate\Support\Facades\Lang {}
23173: class Log extends \Illuminate\Support\Facades\Log {}
23174: class Mail extends \Illuminate\Support\Facades\Mail {}
23175: class Notification extends \Illuminate\Support\Facades\Notification {}
23176: class Password extends \Illuminate\Support\Facades\Password {}
23177: class Queue extends \Illuminate\Support\Facades\Queue {}
23178: class RateLimiter extends \Illuminate\Support\Facades\RateLimiter {}
23179: class Redirect extends \Illuminate\Support\Facades\Redirect {}
23180: class Request extends \Illuminate\Support\Facades\Request {}
23181: class Response extends \Illuminate\Support\Facades\Response {}
23182: class Route extends \Illuminate\Support\Facades\Route {}
23183: class Schema extends \Illuminate\Support\Facades\Schema {}
23184: class Session extends \Illuminate\Support\Facades\Session {}
23185: class Storage extends \Illuminate\Support\Facades\Storage {}
23186: class Str extends \Illuminate\Support\Str {}
23187: class URL extends \Illuminate\Support\Facades\URL {}
23188: class Validator extends \Illuminate\Support\Facades\Validator {}
23189: class View extends \Illuminate\Support\Facades\View {}
23190: class Clockwork extends \Clockwork\Support\Laravel\Facade {}
23191: class Agent extends \Jenssegers\Agent\Facades\Agent {}
23192: class Livewire extends \Livewire\Livewire {}
23193: class Action extends \Lorisleiva\Actions\Facades\Actions {}
23194: class Lody extends \Lorisleiva\Lody\Lody {}
23195: class Stopwatch extends \BeyondCode\ServerTiming\Facades\ServerTiming {}
23196: class Flare extends \Spatie\LaravelIgnition\Facades\Flare {}
23197:
23198: }
23199:
23200:
23201:
23202:
23203: